Hospede um LLM em um VPS.
Sem GPU. Sem chave de API. Nenhum prompt sai daqui.

A versão honesta desta seção vale mais do que uma entusiasmada, porque a forma mais rápida de abandonar um modelo auto-hospedado é apontá-lo para a única tarefa em que ele é pior e concluir que a ideia toda era boba.

Cabe com folga. Qualquer coisa em que a saída seja curta e o valor esteja no julgamento, não na prosa. Classificar uma mensagem em uma entre algumas categorias. Decidir se um chamado de suporte é urgente. Extrair cinco campos de uma fatura como JSON. Resumir uma conversa em três frases. Marcar um documento. Reescrever a descrição de um produto. Traduzir uma string curta. Detectar se dois registros descrevem a mesma pessoa. Remover nomes de um parágrafo antes que ele vá para qualquer outro lugar. Cada uma dessas tarefas consome uma entrada longa e produz uma saída curta, que é exatamente a assimetria que uma CPU lida bem.

Cabe, com paciência. Trabalho sem nenhum humano esperando por ele. Lotes noturnos, workers de fila, uma passagem noturna pelos documentos do dia, um relatório agendado. Se nada fica bloqueado esperando a resposta, uma taxa de tokens que seria intolerável em uma janela de chat deixa de importar por completo — uma tarefa que roda por seis minutos às três da manhã é simplesmente uma tarefa que rodou.

Não cabe. Um assistente interativo que as pessoas realmente gostem de usar: nessas taxas, o cursor rasteja e a experiência é pior do que não ter assistente nenhum. Geração de textos longos — escreva-me duas mil palavras — em que toda a saída é a parte lenta. Agentes de codificação que iteram sobre um repositório grande, em que tanto o contexto quanto o nível de qualidade exigido superam o que um modelo pequeno consegue sustentar. Qualquer coisa que precise de um contexto de cem mil tokens, em que só o cache já ultrapassa a máquina. E modelos de imagem ou vídeo, que são uma disciplina completamente diferente e realmente precisam de uma GPU.

Se a sua carga de trabalho vive nesse último grupo, a resposta sensata não é comprar uma máquina de CPU maior — é um híbrido. Mantenha um modelo local para a maior parte das chamadas e direcione as poucas que precisam de raciocínio de ponta para uma API hospedada, que é exatamente o formato que o guia sobre rodar um agente de IA 24/7 descreve para o lado do runtime. Aquele guia deixou o modelo em si deliberadamente fora do escopo. Este é a metade que faltava.

Primeiro reforce a segurança da máquina — SSH só com chave, um firewall que não permite nada que você não pediu, atualizações de segurança automáticas. A checklist da primeira hora leva cerca de uma hora, e esta é uma máquina que em breve vai guardar cada pergunta que você fizer a ela.

Depois instale o executor. O Ollama é o llama.cpp com um registro de modelos, uma API REST e uma unidade systemd embrulhados ao redor, e o instalador de uma linha configura os três:

apt update && apt install -y curl
curl -fsSL https://ollama.com/install.sh | sh

systemctl status ollama --no-pager
ss -ltnp | grep 11434
# → 127.0.0.1:11434 — loopback only. Leave it that way.

Essa última linha é a que vale a pena ler duas vezes. Por padrão, o serviço escuta na interface de loopback, o que está exatamente certo, e o erro mais comum cometido nos dez minutos seguintes é definir OLLAMA_HOST como 0.0.0.0 porque algo em outra máquina não conseguia alcançá-lo. O passo 04 mostra a forma correta de alcançá-lo; não existe versão disso em que a porta 11434 fica voltada diretamente para a internet.

Duas configurações valem a pena ser feitas agora em vez de descobertas depois. Os modelos são armazenados por padrão em /usr/share/ollama, e eles são grandes, então aponte isso para onde você tiver espaço. E o padrão mantém um modelo residente na RAM por cinco minutos após a última requisição, o que é generoso em uma máquina que também está fazendo outro trabalho:

systemctl edit ollama

[Service]
Environment="OLLAMA_MODELS=/var/lib/ollama/models"
Environment="OLLAMA_KEEP_ALIVE=30m"
Environment="OLLAMA_NUM_PARALLEL=1"
Environment="OLLAMA_MAX_LOADED_MODELS=1"

systemctl daemon-reload && systemctl restart ollama

Requisições paralelas e múltiplos modelos carregados multiplicam o uso de memória, e em uma máquina dimensionada para segurar exatamente um modelo não sobra um gigabyte para uma segunda cópia. Serializar a fila não é uma limitação deste hardware; é a única configuração que não derruba tudo.

Esta é a parte do guia que impede algo ruim de acontecer, então ela é dita sem meias palavras: a API do Ollama não tem senha, não tem token, não tem modelo de usuário e não tem sistema de permissões. O que quer que consiga abrir uma conexão TCP na porta 11434 pode gerar texto na sua CPU, enumerar os modelos que você baixou, baixar novos e apagar os que você usa. Não há configuração para ativar, porque não há mecanismo para ativar.

A porta 11434 é escaneada continuamente, pelo motivo óbvio: um executor de modelo aberto é computação gratuita pertencente a outra pessoa. O sintoma não é um alerta. É uma máquina que parece lenta por duas semanas e um gráfico de banda que não corresponde a nada que você fez. Mantenha o serviço no loopback, e coloque algo na frente dele que pergunte quem está chamando.

Se nada fora desta máquina precisa do modelo, pare por aqui — você já terminou. Loopback mais um firewall já é uma resposta completa, e um agente, uma stack de automação ou uma aplicação web rodando no mesmo VPS acessa o modelo via 127.0.0.1 sem nada do que vem a seguir. Só continue se algo em outra máquina precisar chamá-lo.

O proxy, e o token. Gere um token longo e aleatório, aponte um registro A para a máquina, e deixe o Caddy cuidar tanto do certificado quanto da porta:

openssl rand -hex 32      # → the bearer token, store it in a password manager
apt install -y caddy

/etc/caddy/Caddyfile

llm.example.com {
    @unauthorised not header Authorization "Bearer PASTE_THE_HEX_TOKEN_HERE"
    respond @unauthorised "unauthorised" 401

    reverse_proxy 127.0.0.1:11434 {
        # Generation is slow by nature — do not let the proxy give up first.
        transport http {
            read_timeout 10m
        }
    }
}

systemctl reload caddy
ufw allow 80,443/tcp
ufw status                # 11434 must appear nowhere

Há uma pequena elegância em escolher um token Bearer em vez de autenticação básica. O Ollama expõe uma API compatível com OpenAI, todo cliente OpenAI envia sua chave exatamente nesse header, e assim o token que você acabou de gerar se torna a chave de API que suas aplicações já sabem carregar. Nada precisa de um header personalizado, e girar o acesso é uma linha no Caddyfile e uma variável de ambiente em quem chama.

Verifique a partir de uma máquina que não seja o servidor. A primeira chamada deve ser recusada e a segunda deve responder:

curl -s -o /dev/null -w '%{http_code}\n' https://llm.example.com/api/tags
# → 401

curl -s https://llm.example.com/api/tags -H "Authorization: Bearer THE_TOKEN" | jq '.models[].name'
# → the list of models you pulled

Se o modelo vai ser chamado por agentes em vez de por você, a questão da exposição merece o tratamento mais completo do guia sobre hospedar um servidor MCP remoto — o mesmo raciocínio sobre TLS, tokens e o que deve ser alcançável de onde, aplicado a um serviço que entrega ferramentas em vez de tokens.

Limite o contexto. O tamanho do contexto é o principal controle sobre o uso de memória, e o padrão é mais generoso do que uma máquina pequena quer. Defina-o globalmente para o que o seu prompt mais longo realmente precisa — a maior parte do trabalho de classificação e extração é confortável dentro de quatro mil tokens — e aumente por requisição nas raras chamadas que precisam de mais:

Environment="OLLAMA_CONTEXT_LENGTH=4096"

curl -s http://127.0.0.1:11434/api/generate -d '{
  "model": "llama3.1:8b",
  "prompt": "…a long document…",
  "options": { "num_ctx": 16384 },
  "stream": false
}'

Decida por quanto tempo o modelo fica na memória. Um modelo residente responde instantaneamente e mantém vários gigabytes reféns. Em uma máquina dedicada à inferência, mantenha-o carregado para sempre; em uma compartilhada, deixe-o descarregar depois de um tempo. O valor também pode ser definido por requisição, então um lote noturno pode fixar o modelo durante sua execução e liberá-lo no final:

OLLAMA_KEEP_ALIVE=-1     # resident until the service restarts
OLLAMA_KEEP_ALIVE=30m    # a sensible default on a shared box
OLLAMA_KEEP_ALIVE=0      # unload immediately after each request

ollama ps                # what is resident right now, and how much it holds

Serialize a fila. Duas requisições simultâneas contra um modelo não vão duas vezes mais rápido; elas disputam o mesmo caminho de memória saturado e cada uma fica mais lenta, e se o Ollama decidir carregar uma segunda cópia para atendê-las, a máquina fica sem RAM. Nesta classe de hardware, uma requisição de cada vez, com uma fila na frente, é ao mesmo tempo a configuração mais rápida e a única segura — por isso OLLAMA_NUM_PARALLEL e OLLAMA_MAX_LOADED_MODELS foram fixados em um lá no passo 02.

Fique de olho no disco. Comparar quatro modelos deixa quatro modelos para trás, e a cinco gigabytes cada, isso é um disco enchendo silenciosamente enquanto nada reclama. Torne a limpeza parte da comparação, não uma tarefa para depois:

ollama list
du -sh /var/lib/ollama/models
ollama rm mistral:7b qwen2.5:14b

Por fim, faça backup do que não é reproduzível. Os pesos do modelo não são — um pull os traz de volta. O que vale um repositório é a configuração, o Caddyfile, o token, os prompts que você refinou ao longo de três semanas e, se você construiu um, o índice vetorial por trás da sua recuperação. O guia de backups criptografados cobre a mecânica; a lista de inclusão para esta máquina é curta e vale a pena anotar.

As pessoas pensam sobre a privacidade de modelos como se o risco estivesse na saída. Não está. A saída é texto genérico; mil outras pessoas receberam algo parecido. O artefato revelador é a entrada — e um ano de entradas é um retrato surpreendentemente completo de uma organização.

Pense no que um log de requisições realmente contém. O contrato que você colou para ser resumido. O e-mail do cliente que você pediu para classificar, com o cliente lá dentro. A carta médica, o valor do salário, a carta de demissão que você estava rascunhando, o código de um repositório que não é público. Depois os metadados ao redor disso: quais perguntas, em que ordem, a que horas, de qual endereço, ao longo de quantos meses. Ninguém assina um documento dizendo "aqui está nossa estratégia" — mas a sequência de perguntas é esse documento, montado honestamente, por você, uma chamada de cada vez.

Camada um — o que o endpoint guarda. Provedores sérios publicam políticas sérias, e os bons realmente não treinam com o tráfego da API de negócios. Isso não é a mesma promessa que não reter os dados. As requisições costumam ficar armazenadas por um período para monitoramento de abuso, são acessíveis pela equipe sob condições definidas, e podem ser produzidas sob processo legal — o que é exatamente a forma certa de operar uma plataforma grande e exatamente o lugar errado para um texto que você não mandaria por e-mail a um estranho. Um modelo na sua própria máquina não tem esse log, a menos que você crie um.

Camada dois — a identidade à qual o log está associado. A retenção sozinha é só metade da exposição. A outra metade é a chave à qual ela se junta: uma conta, um nome de empresa, um endereço de cobrança, um cartão. Essa junção é o que transforma "alguém perguntou sobre adquirir um concorrente" em "esta empresa perguntou, naquela terça-feira". Remover o modelo da equação remove a retenção; remover a identidade da máquina remove a junção. Um VPS aberto sem endereço de e-mail nem documento de identidade, em uma jurisdição nórdica, quitado em Monero, é a segunda metade do mesmo movimento.

Camada três — os logs que você mesmo escreve. A auto-hospedagem move o risco em vez de eliminá-lo, e vale a pena ter clareza sobre onde ele pousa. Sua aplicação provavelmente registra os próprios prompts. Seu proxy reverso registra cada linha de requisição. Uma sessão de depuração de dois meses atrás deixou saída detalhada no journal. O modelo em si não guarda nada entre chamadas, mas a maquinaria ao redor dele pode guardar tudo — então decida deliberadamente o que fica registrado, defina uma retenção para isso, e cobre desse log o mesmo padrão que você não estava disposto a aceitar de outra pessoa.

Nada disso faz de um modelo local uma garantia de privacidade por si só. Faz dele a única arquitetura em que a garantia é sua para dar: o texto fica em um hardware que você aluga, sob uma jurisdição que você escolheu, atrás de um token que você emitiu, e não presta contas a mais nada.