Infraestrutura
Open WebUI e Ollama em VPS: CPU ou GPU?
Instale Open WebUI e Ollama em VPS, dimensione CPU, RAM e GPU, configure Docker e HTTPS, proteja o acesso e otimize modelos locais com firewall e backup.
Resposta direta
É possível rodar Open WebUI e Ollama em uma VPS usando Docker, desde que o servidor tenha memória suficiente para carregar o modelo escolhido. Para modelos de 7 a 8 bilhões de parâmetros quantizados em 4 bits, um ponto de partida razoável é 4 vCPUs, 16 GB de RAM e 80 GB de SSD ou NVMe. Uma instalação pequena pode funcionar com 8 GB, mas ficará com pouca margem para contexto, sistema operacional e usuários simultâneos. A GPU não é obrigatória: a CPU atende testes, automações de baixo volume e conversas ocasionais, enquanto uma GPU NVIDIA compatível com o NVIDIA Container Toolkit reduz a latência em cargas interativas. Em produção, publique somente o Open WebUI por HTTPS, mantenha a porta 11434 do Ollama fora da internet e faça backup dos dados da interface, configurações e arquivos necessários para reconstruir o ambiente.
Resumo rápido
- Open WebUI fornece a interface, usuários e histórico; Ollama carrega e executa os modelos.
- Uma VPS com 4 vCPUs e 16 GB de RAM é um início mais confortável para modelos 7B ou 8B em Q4.
- CPU funciona para laboratório e baixo volume, mas a geração tende a ficar mais lenta que em GPU.
- O tamanho do arquivo do modelo não representa todo o consumo de RAM, pois contexto e cache também ocupam memória.
- SSD ou NVMe ajuda no carregamento, nas atualizações e na operação geral, mas não substitui CPU, RAM ou GPU adequadas.
- A porta 11434 não deve ficar aberta para a internet; exponha apenas o proxy HTTPS nas portas 80 e 443.
- Docker Compose facilita persistência, atualização controlada e recuperação depois de uma falha.
Antes de contratar recursos, escolha primeiro o modelo e a quantidade provável de usuários. Essa ordem evita pagar por uma GPU ociosa ou descobrir tarde demais que 8 GB de RAM não comportam o modelo, o contexto e os serviços auxiliares. Para uma visão mais ampla de arquitetura, regiões e workloads, consulte também o conteúdo sobre Cloud Server para IA e LLM self-hosted.
Como Open WebUI e Ollama funcionam juntos
O papel de cada componente
O Ollama é o servidor de inferência. Ele baixa modelos compatíveis, mantém os arquivos em disco, carrega os pesos na memória e oferece uma API HTTP na porta 11434. O Open WebUI fica na camada de aplicação: apresenta a tela de conversa, gerencia usuários, armazena históricos e encaminha as solicitações ao Ollama. Separar esses papéis ajuda no diagnóstico. Se a página abre, mas nenhum modelo responde, o problema costuma estar na comunicação com a API, no carregamento do modelo ou na falta de recursos, não necessariamente na interface.
Em uma instalação simples, os dois serviços rodam na mesma VPS e se comunicam por uma rede privada do Docker. O navegador acessa um proxy reverso por HTTPS, o proxy envia a requisição ao Open WebUI e somente o Open WebUI alcança o Ollama. Não existe motivo operacional para publicar a porta 11434 em um IP público nesse cenário. Uma exceção seria uma API consumida por outra rede confiável, ainda assim protegida por VPN, autenticação adicional ou uma camada própria de API gateway.
Um exemplo de laboratório pode ter um usuário, um modelo 7B quantizado e poucas conversas por dia. Uma equipe interna já pode ter cinco pessoas enviando prompts ao mesmo tempo, documentos anexados e contextos maiores. A arquitetura parece igual, mas o segundo caso exige mais memória, limites de uso e observabilidade. Em um projeto com RAG, ainda aparecem componentes como banco vetorial, pipeline de embeddings e armazenamento de documentos, que precisam entrar no cálculo.
VPS tradicional ou Cloud Server
Uma VPS tradicional normalmente entrega uma máquina virtual em um host físico, com recursos e opções de expansão definidos pelo provedor. Cloud Server e cloud instance podem oferecer provisionamento mais flexível, discos desacoplados, redes privadas e troca de tamanho com menos etapas, mas esses recursos variam entre plataformas. O nome comercial, sozinho, não garante alta disponibilidade ou CPU dedicada.
Para um laboratório, uma VPS comum pode atender bem. Para uma equipe que pretende aumentar RAM, anexar volumes ou migrar para GPU, uma infraestrutura cloud tende a simplificar a evolução. Quem ainda está organizando a camada de contêineres pode usar o tutorial de VPS para Docker como base para volumes, redes, atualizações e logs.
Como dimensionar CPU, RAM, disco e GPU
Memória exigida pelo modelo
O dimensionamento começa pelo modelo, não pela interface. Um modelo de 7B ou 8B quantizado em Q4 costuma ter arquivo na faixa aproximada de 4,5 a 6 GB, mas a execução precisa de memória adicional para contexto, cache KV, buffers e processos do sistema. Por isso, 8 GB de RAM pode iniciar alguns modelos pequenos, porém deixa pouca folga. Com 16 GB, a operação fica mais previsível para um usuário e permite testar contextos moderados sem depender constantemente de swap.
Modelos de aproximadamente 14B em Q4 podem exigir perto de 9 a 12 GB apenas para pesos e estruturas associadas, dependendo da arquitetura e da quantização. Uma VPS com 24 ou 32 GB é uma base mais prudente. Na classe de 30B a 32B, o consumo pode ultrapassar 20 GB antes de considerar contextos longos e concorrência. Esses números são referências de planejamento, não garantias universais. A versão do modelo, a quantização e o tamanho do contexto mudam o resultado.
| Perfil de uso | CPU | RAM | Disco persistente | GPU ou VRAM | Cenário provável |
|---|---|---|---|---|---|
| Laboratório econômico | 4 vCPUs | 8 a 16 GB | 60 a 100 GB SSD | Sem GPU | Modelo 3B a 8B, um usuário, prompts ocasionais |
| Uso individual frequente | 8 vCPUs | 16 a 32 GB | 100 a 200 GB SSD ou NVMe | Opcional, 8 a 12 GB de VRAM | Modelo 7B ou 8B, contexto moderado, uso diário |
| Equipe pequena | 8 a 16 vCPUs | 32 a 64 GB | 200 GB ou mais | 16 a 24 GB de VRAM | Vários usuários, RAG e modelos 8B a 14B |
| Produção especializada | Conforme benchmark | 64 GB ou mais | Volume dimensionado e monitorado | Uma ou mais GPUs | Concorrência, modelos maiores e metas de latência |
O disco precisa acomodar múltiplas versões de modelos. Três modelos de 5 GB já consomem 15 GB, e downloads interrompidos, logs, imagens Docker e backups locais ampliam o total. Reservar pelo menos 30% de espaço livre reduz problemas durante atualizações. NVMe acelera leitura, extração e carregamento, mas a geração de tokens continua limitada principalmente por CPU, largura de banda da memória ou GPU.
Quando uma GPU compensa
CPU faz sentido para aprender, validar integrações e executar automações sem exigência de resposta imediata. Oito vCPUs não equivalem a oito núcleos físicos dedicados, e a variação do host pode afetar a inferência. Uma GPU passa a fazer sentido quando a espera prejudica o uso, há vários usuários ou o modelo precisa responder continuamente. Antes de contratar, confirme o modelo exato da GPU, a VRAM disponível, o driver e a compatibilidade com contêineres. O artigo sobre Cloud Server com GPU no Brasil explica os critérios de região, disponibilidade e custo sem assumir que toda GPU serve ao mesmo workload.
Como preparar a VPS para a instalação
Sistema operacional, Docker e firewall
Uma base conservadora é Ubuntu Server 22.04 ou 24.04 LTS, arquitetura x86_64, acesso SSH por chave e um usuário administrativo com sudo. Comece atualizando os pacotes e instalando ferramentas básicas. Não execute instaladores desconhecidos diretamente por pipe sem revisar a origem e o conteúdo. Para Docker, prefira o repositório e a documentação oficiais, pois versões antigas distribuídas pelo sistema podem não incluir recursos recentes do Compose.
sudo apt update
sudo apt upgrade -y
sudo apt install -y ca-certificates curl gnupg ufw
Configure o firewall antes de publicar a aplicação. Em uma implantação com Nginx ou Caddy no host, SSH, HTTP e HTTPS são as únicas portas públicas normalmente necessárias. Restrinja o SSH ao IP administrativo sempre que houver um endereço estável. Se isso não for possível, use chaves, desative login por senha e acompanhe tentativas de acesso.
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow OpenSSH
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable
O comando não abre 3000 nem 11434. A interface será ligada ao endereço local 127.0.0.1 e alcançada pelo proxy reverso. Esse desenho reduz exposição acidental. Em provedores que também oferecem firewall de rede, replique a política na borda. As duas camadas são complementares, desde que as regras não bloqueiem o tráfego legítimo de retorno.
Diretórios e persistência
Crie um diretório exclusivo para a stack e mantenha o arquivo Compose sob controle de versão privado, sem segredos. Os dados persistentes podem ficar em volumes nomeados do Docker. Essa escolha evita permissões inconsistentes e simplifica a primeira instalação. Bind mounts são úteis quando a equipe precisa inspecionar os arquivos diretamente, mas exigem cuidado com proprietário, grupo e backup.
sudo mkdir -p /opt/ai-stack
sudo chown $USER:$USER /opt/ai-stack
cd /opt/ai-stack
touch compose.yaml
Em uma VPS com apenas 8 GB, um arquivo de swap pode impedir que o kernel encerre processos durante um pico, mas não transforma disco em RAM rápida. Um swap de 4 a 8 GB serve como proteção temporária. Se o Ollama usa swap continuamente, reduza o modelo ou aumente a memória. Para GPU NVIDIA, instale o driver e o NVIDIA Container Toolkit conforme a documentação oficial, depois valide com nvidia-smi antes de alterar o Compose.
Instalação com Docker Compose
Subindo os contêineres
O arquivo abaixo cria uma rede interna, dois volumes persistentes e publica o Open WebUI apenas no loopback do host. O Ollama não recebe uma porta pública. Fixar versões específicas das imagens é mais seguro em produção do que acompanhar uma tag móvel, mas as tags disponíveis precisam ser conferidas nos registros oficiais durante a implantação.
services:
ollama:
image: ollama/ollama:latest
container_name: ollama
restart: unless-stopped
volumes:
- ollama_data:/root/.ollama
networks:
- ai_internal
open-webui:
image: ghcr.io/open-webui/open-webui:main
container_name: open-webui
restart: unless-stopped
depends_on:
- ollama
environment:
OLLAMA_BASE_URL: http://ollama:11434
volumes:
- open_webui_data:/app/backend/data
ports:
- 127.0.0.1:3000:8080
networks:
- ai_internal
volumes:
ollama_data:
open_webui_data:
networks:
ai_internal:
driver: bridge
Suba os serviços e acompanhe os primeiros logs. O download inicial das imagens pode ocupar alguns gigabytes. Antes de concluir que o processo travou, confira uso de disco, DNS e conectividade do servidor.
docker compose pull
docker compose up -d
docker compose ps
docker compose logs --tail=100 open-webui
docker compose logs --tail=100 ollama
Para validar localmente, execute curl -I http://127.0.0.1:3000. Uma resposta HTTP confirma que a interface está ouvindo, embora ainda falte configurar HTTPS. Se o Open WebUI informar que não encontra o Ollama, confirme o valor de OLLAMA_BASE_URL, o nome do serviço e a rede compartilhada. Usar localhost:11434 dentro do contêiner apontaria para o próprio Open WebUI, não para o outro serviço.
Baixando e testando um modelo
Baixe um modelo pelo próprio contêiner. O nome exato deve ser escolhido na biblioteca oficial do Ollama. Um modelo pequeno permite validar a stack antes de consumir dezenas de gigabytes.
docker exec -it ollama ollama list
docker exec -it ollama ollama pull llama3.2:3b
docker exec -it ollama ollama run llama3.2:3b
Depois do teste, abra a interface por meio do túnel SSH ou termine a configuração do proxy. No primeiro acesso, crie a conta administrativa usando uma senha exclusiva. Não inclua senhas, tokens ou chaves no compose.yaml. Se uma integração externa exigir segredo, use um arquivo .env com permissão restrita, secrets do orquestrador ou um cofre de credenciais.
Em servidores com GPU, o serviço Ollama precisa receber acesso ao dispositivo. No Docker Compose moderno, isso pode ser feito com a configuração de GPU suportada pela versão instalada. Valide primeiro com um contêiner de teste e nvidia-smi. Só depois confirme nos logs do Ollama se camadas foram realmente descarregadas para a GPU. Ter uma GPU anexada à VM não garante que o contêiner esteja usando CUDA.
Segurança, HTTPS, backup e operação
Publicação segura com proxy reverso
A interface não deve ser publicada diretamente em HTTP. Configure um domínio, crie um registro DNS para o IP da VPS e use Nginx, Caddy ou Traefik para terminar TLS. Com Nginx no host, o destino pode ser http://127.0.0.1:3000. O proxy precisa encaminhar cabeçalhos como Host, X-Forwarded-For e X-Forwarded-Proto, além de suportar conexões longas usadas durante a geração da resposta.
Mantenha o cadastro público desativado quando a instância for privada. O primeiro usuário costuma assumir funções administrativas em instalações novas, então a janela entre publicação e configuração deve ser curta. Para uma equipe, combine autenticação da aplicação com VPN, lista de IPs ou identidade corporativa quando o ambiente e a edição usada permitirem. A aplicação também precisa de limites organizacionais: quem pode baixar modelos, enviar documentos, criar integrações e manter históricos?
A API do Ollama merece atenção especial. Uma regra de firewall bloqueando 11434 ajuda, mas o desenho mais seguro é não publicar essa porta no Docker. Teste externamente com uma máquina fora da rede. As portas esperadas são 80 e 443, além do SSH quando autorizado. Ferramentas como ss -tulpn, docker ps e uma varredura controlada do próprio IP ajudam a encontrar exposições acidentais.
O que precisa entrar no backup
O volume open_webui_data contém informações da interface, como usuários, configurações e históricos, dependendo da versão. O volume ollama_data contém modelos que podem ocupar muito espaço. Há duas estratégias possíveis. A primeira salva ambos e acelera a recuperação. A segunda salva a interface e a lista de modelos, depois baixa os pesos novamente. A escolha depende do tempo aceitável de restauração, da velocidade de rede e do custo do armazenamento.
Faça backup consistente, com os contêineres parados ou usando um método compatível com o banco interno da aplicação. Um exemplo simples é interromper brevemente a stack, arquivar os volumes e enviar a cópia para um destino externo criptografado. Não deixe o único backup na mesma VPS. Teste a restauração em um servidor separado a cada atualização relevante.
Atualizações também precisam de rotina. Registre a versão atual, leia notas de lançamento, gere backup, baixe a nova imagem e recrie os serviços. Se ocorrer incompatibilidade, volte para a tag anterior. Tags móveis como latest e main são práticas em laboratório, mas reduzem previsibilidade em produção.
Como diagnosticar lentidão e falta de memória
Métricas que ajudam a encontrar o gargalo
Comece observando CPU, memória, swap, disco e logs durante uma solicitação real. docker stats mostra o consumo dos contêineres, enquanto free -h, vmstat 1 e iostat -xz 1 ajudam a separar falta de RAM de espera por disco. Em GPU NVIDIA, use nvidia-smi para conferir VRAM, utilização e processos. Colete as métricas com o mesmo modelo, prompt e tamanho de contexto, pois trocar essas variáveis invalida a comparação.
Se a CPU permanece próxima de 100% durante toda a geração, sem pressão de memória, o limite provável é computacional. Mais vCPUs podem ajudar, mas o ganho depende da arquitetura, da disponibilidade real dos núcleos e da largura de banda da memória. Se o sistema começa a usar swap e a latência cresce de forma abrupta, o modelo ou o contexto não cabe confortavelmente na RAM. Se o disco fica cheio durante um pull, remova modelos e imagens não utilizados antes de repetir o download.
Três testes simples esclarecem boa parte dos casos. Primeiro, execute o mesmo prompt em um modelo 3B e em um 8B. Segundo, reduza o contexto e abra apenas uma conversa. Terceiro, compare uma execução logo após carregar o modelo com outra após período ocioso. A primeira pode incluir tempo de carregamento dos pesos, enquanto as seguintes reutilizam o modelo residente.
Ajustes práticos para reduzir consumo
Use quantização mais compacta quando a qualidade continuar adequada ao caso de uso. Reduza o contexto máximo se as conversas não exigirem milhares de tokens anteriores. Limite a quantidade de usuários simultâneos e evite manter vários modelos grandes carregados sem necessidade. Em RAG, diminua a quantidade de trechos recuperados e escolha embeddings proporcionais ao problema, em vez de anexar documentos inteiros ao prompt.
Um desenvolvedor que resume tickets pode preferir um modelo 3B ou 7B rápido. Uma equipe jurídica avaliando documentos longos talvez precise de mais contexto, memória e testes de qualidade. Já uma automação noturna aceita maior latência e pode permanecer em CPU. Não existe uma configuração universal. Registre tokens por segundo, tempo até o primeiro token, memória máxima e taxa de erros antes de decidir pelo upgrade.
Recomendações por perfil
Desenvolvedor solo e laboratório
Para aprender e validar integrações, comece com 4 vCPUs, 8 a 16 GB de RAM e 80 GB de SSD. Use um modelo 3B para testar a instalação e depois experimente um 7B ou 8B quantizado. A CPU é suficiente quando as conversas são ocasionais e alguns segundos adicionais não interrompem o trabalho. Publique a interface somente por túnel SSH ou HTTPS, mesmo em laboratório. Monitore swap e mantenha pelo menos 20 a 30 GB livres para imagens e downloads temporários. Se o projeto não avançar, essa configuração evita o custo contínuo de uma GPU subutilizada.
Equipe pequena
Para três a dez usuários, considere 8 a 16 vCPUs, 32 GB de RAM e 150 a 250 GB de SSD ou NVMe. Uma GPU com 16 a 24 GB de VRAM pode melhorar a experiência com modelos 8B ou 14B, desde que testes confirmem compatibilidade e capacidade. Implemente autenticação restrita, backup externo, monitoramento de disco e limites de uso. Se houver RAG, contabilize banco vetorial, embeddings e documentos. Faça um teste de concorrência com prompts representativos antes de liberar a ferramenta para toda a equipe, pois uma demonstração com um usuário não revela filas e picos de memória.
Produção e múltiplos usuários
Em produção, dimensione com benchmark próprio. Comece medindo tempo até o primeiro token, taxa de geração, VRAM, RAM e concorrência no modelo final. Separe interface, inferência e armazenamento quando a falha de um componente não puder interromper toda a operação. Uma ou mais GPUs podem ser necessárias, mas a quantidade depende do modelo, da quantização e da meta de latência. Adote tags de imagem fixas, logs centralizados, alertas, backup testado e procedimento de rollback. Dados sensíveis exigem política de retenção, controle de acesso e revisão sobre o que usuários podem enviar aos modelos. A recomendação final deve considerar segurança e recuperação, não apenas velocidade.
Continue lendo
Perguntas frequentes
Quanta RAM uma VPS precisa para rodar Open WebUI e Ollama?
A interface Open WebUI consome relativamente pouco perto do modelo, então a RAM deve ser calculada a partir do Ollama. Para um modelo 3B quantizado, 8 GB podem atender testes. Modelos 7B ou 8B em Q4 ficam mais confortáveis com 16 GB. Para modelos próximos de 14B, considere 24 a 32 GB. O arquivo do modelo não representa todo o consumo: contexto, cache KV, sistema operacional e usuários simultâneos também usam memória. Se houver swap constante ou encerramentos por falta de memória, reduza o modelo ou aumente a RAM.
É obrigatório usar GPU para executar o Ollama?
Não. O Ollama pode executar modelos em CPU, o que atende laboratórios, automações de baixo volume e conversas ocasionais. A desvantagem costuma ser a maior latência, especialmente em modelos grandes ou com contextos longos. Uma GPU torna-se mais interessante quando vários usuários acessam a aplicação, a resposta precisa ser interativa ou a inferência ocorre continuamente. Antes da contratação, confirme o modelo da GPU, a quantidade de VRAM, os drivers e o suporte ao NVIDIA Container Toolkit. O ganho real deve ser medido com o modelo e os prompts usados pela aplicação.
Posso expor a porta 11434 do Ollama na internet?
A opção mais segura é não expor a porta 11434 publicamente. Em uma stack com Open WebUI, os dois contêineres podem conversar por uma rede privada do Docker, enquanto somente a interface fica acessível por um proxy HTTPS. Se outra aplicação precisar consumir a API, prefira rede privada, VPN ou um gateway com autenticação, limites e logs. Uma regra de firewall ajuda, mas não substitui uma arquitetura sem publicação da porta. Depois da instalação, verifique as portas abertas com `ss -tulpn` e faça um teste externo controlado.
SSD NVMe melhora a velocidade de geração dos modelos?
NVMe reduz o tempo de download, leitura e carregamento dos modelos, além de ajudar em atualizações, logs e bancos auxiliares. Depois que os pesos estão carregados, a geração costuma depender mais da CPU, da largura de banda da memória ou da GPU. Portanto, trocar SSD por NVMe não corrige sozinho uma inferência lenta causada por poucas vCPUs ou VRAM insuficiente. O benefício é maior quando modelos são carregados e descarregados com frequência ou quando a mesma máquina executa banco vetorial e processamento de documentos. Meça carregamento e geração separadamente antes de investir.
Como atualizar Open WebUI e Ollama sem perder os dados?
Mantenha os dados em volumes persistentes, gere um backup e registre as versões atuais antes da atualização. Em produção, prefira tags de imagem específicas em vez de acompanhar automaticamente `main` ou `latest`. Depois, execute `docker compose pull` e `docker compose up -d`, verifique os logs e teste autenticação, modelos e históricos. Se houver incompatibilidade, restaure a tag anterior e, quando necessário, o backup. O procedimento deve ser testado primeiro em uma cópia do ambiente. Atualizar imagens sem backup pode dificultar o rollback quando há migração do banco interno.
Qual modelo devo usar na primeira instalação?
Comece com um modelo pequeno, como um 3B quantizado disponível na biblioteca oficial do Ollama. Ele permite validar rede, volumes, interface e consumo sem comprometer toda a memória. Depois, compare um modelo 7B ou 8B usando prompts reais do projeto. Registre qualidade, tempo até o primeiro token, velocidade de geração e pico de RAM. Para tarefas simples de resumo ou classificação, o modelo menor pode bastar. Código, documentos longos e raciocínio mais complexo podem exigir modelos maiores, mas a escolha deve considerar qualidade medida, licenciamento e capacidade do servidor.
Fontes consultadas
- Ollama Documentation · coletado em 10/11/2026
- Open WebUI Documentation · coletado em 10/11/2026
- Docker Engine Installation for Ubuntu · coletado em 10/11/2026
- NVIDIA Container Toolkit Documentation · coletado em 10/11/2026