Como rodar aplicações de IA open source com Docker em um VPS: guia prático para iniciantes e intermediários

O poder da inteligência artificial está ao alcance de um comando docker run — e você não precisa de um data center para isso.

Em 2025, executar modelos de linguagem (LLMs), geradores de imagem como Stable Diffusion ou ferramentas de transcrição de áudio localmente não é mais um luxo restrito a grandes empresas. Com a combinação certa de containers Docker e uma VPS com GPU, qualquer desenvolvedor pode montar seu próprio data center pessoal de IA, ganhando controle total sobre os dados, eliminando custos de API terceirizada e explorando o vasto ecossistema open source sem depender de provedores como OpenAI ou Google.

Neste guia prático, você aprenderá desde a escolha do provedor ideal até a otimização de performance com CUDA e Docker. Se você já tem familiaridade básica com Linux e containers, mas quer dar o salto para aplicações de IA self-hosted, este artigo é para você.

Por que Docker + VPS para IA self-hosted?

A premissa é simples: Docker empacota toda a dependência do modelo de IA em um container isolado, enquanto a VPS oferece o hardware (CPU, RAM e, idealmente, GPU) para rodar cargas de trabalho intensivas. Juntos, eles resolvem três problemas clássicos:

• Reprodutibilidade: “Funciona na minha máquina” vira “funciona em qualquer VPS que tenha Docker”.
• Escalabilidade: Aumente recursos ou adicione réplicas com um docker-compose up.
• Privacidade: Seus dados nunca saem do seu servidor — essencial para aplicações sensíveis (saúde, jurídico, finanças).

Além disso, o ecossistema open source de IA amadureceu. Hoje você encontra imagens oficiais para Llama 3, Mistral, Whisper, Stable Diffusion, ComfyUI, GPT4All, Ollama e dezenas de outros modelos, com comunidades ativas e documentação em constante atualização.

Passo 0: Escolhendo a VPS certa para IA

Nem toda VPS serve para rodar IA. Você precisa considerar três recursos principais:

Provedores que oferecem GPUs acessíveis:
- Vultr — instâncias com T4 a partir de $0.89/hora.
- Hetzner — servidores dedicados com RTX 4000 por ~€70/mês.
- Lambda Labs — focado em deep learning, preços competitivos.
- RunPod — pague por segundo de GPU.

💡 Dica de economia: Para testes iniciais, use instâncias on-demand e desligue quando não estiver usando. Para produção, considere reservas anuais com desconto.

Passo 1: Preparando o ambiente — Docker e NVIDIA Container Toolkit

Antes de pular para os modelos, precisamos preparar o host. Os comandos abaixo são para Ubuntu 22.04/24.04 LTS (a distribuição mais comum em VPS).

Instalando Docker Engine

# Atualiza repositórios
sudo apt update && sudo apt upgrade -y

# Instala dependências
sudo apt install ca-certificates curl gnupg lsb-release -y

# Adiciona chave GPG oficial do Docker
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

# Configura repositório
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Instala Docker
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin -y

# Adiciona seu usuário ao grupo docker (evita sudo)
sudo usermod -aG docker $USER

Saia e entre novamente para aplicar o grupo.

Instalando NVIDIA Drivers e Container Toolkit

Se sua VPS tem GPU NVIDIA, siga:

# Detecta a GPU
lspci | grep NVIDIA

# Instala drivers NVIDIA (recomendado: versão 535+)
sudo apt install nvidia-driver-535 nvidia-utils-535 -y

# Reinicia (ou carrega módulo)
sudo reboot

Após o reboot, instale o runtime NVIDIA para Docker:

distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list

sudo apt update && sudo apt install nvidia-container-toolkit -y
sudo systemctl restart docker

Teste se o Docker enxerga a GPU:

docker run --rm --gpus all nvidia/cuda:12.2.0-base-ubuntu22.04 nvidia-smi

Se você ver a saída do nvidia-smi, o ambiente está pronto.

Passo 2: Deploy de um LLM com Ollama (container pronto)

Ollama simplifica a execução de LLMs locais. Vamos rodar o Llama 3.2 3B (modelo leve, ideal para VPS com 8GB VRAM):

docker run -d --gpus all -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

Agora faça o download e execute o modelo:

docker exec -it ollama ollama pull llama3.2:3b
docker exec -it ollama ollama run llama3.2:3b "Explique o que é Docker em 3 frases."

Resposta esperada (em segundos): Docker é uma plataforma de containers que empacota aplicações e dependências. Ele isola processos em ambientes leves. Facilita deploy e escalabilidade.

Para integrar com sua aplicação, a API REST fica em http://SEU_VPS_IP:11434/api/generate. Exemplo de requisição:

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2:3b",
  "prompt": "O que é Docker?",
  "stream": false
}'

Gerenciando múltiplos modelos

Crie um docker-compose.yml para ter Ollama + uma interface web (Open WebUI):

version: '3.8'

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    volumes:
      - ollama_data:/root/.ollama
    ports:
      - "11434:11434"
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

  open-webui:
    image: ghcr.io/open-webui/open-webui:latest
    container_name: open-webui
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    volumes:
      - webui_data:/app/backend/data
    depends_on:
      - ollama

volumes:
  ollama_data:
  webui_data:

Subindo: docker compose up -d. Acesse http://SEU_VPS_IP:3000 para um ChatGPT-like self-hosted.

Passo 3: Gerando imagens com Stable Diffusion + ComfyUI

O ComfyUI é a ferramenta mais flexível para geração de imagens com Stable Diffusion. Vamos containerizá-la com suporte CUDA:

docker run -d --gpus all \
  -p 8188:8188 \
  -v comfyui_data:/workspace \
  --name comfyui \
  nvidia/cuda:12.2.0-base-ubuntu22.04 \
  bash -c "git clone https://github.com/comfyanonymous/ComfyUI /workspace && cd /workspace && pip install -r requirements.txt && python main.py --listen 0.0.0.0 --port 8188"

Esse comando é didático, mas na prática use a imagem oficial otimizada:

docker run -d --gpus all \
  -p 8188:8188 \
  -v comfyui_data:/workspace \
  --name comfyui \
  akhilesh2001/comfyui:latest

Acesse http://SEU_VPS_IP:8188. Dentro da interface, faça o download de um modelo (ex: SDXL base 1.0 diretamente do site CivitAI). Coloque o .safetensors na pasta models/checkpoints/ do volume montado.

Exemplo de prompt para estilo Ghibli:

A magical forest with floating lanterns, Ghibli style, soft lighting, cel shaded, vibrant colors, hayao miyazaki, masterpiece

A geração em uma T4 16GB leva de 5 a 15 segundos por imagem (dependendo do número de passos e resolução).

Passo 4: Transcrição de áudio com Whisper (OpenAI)

O Whisper da OpenAI é o estado da arte em transcrição. Com Docker, você pode expor uma API REST. Use o container onerahmet/openai-whisper-asr-webservice:

docker run -d --gpus all \
  -p 9000:9000 \
  -e ASR_MODEL=medium \
  -v whisper_data:/data \
  --name whisper \
  onerahmet/openai-whisper-asr-webservice:latest-gpu

Teste com um arquivo de áudio:

curl -F "audio_file=@/caminho/para/audio.mp3" http://localhost:9000/asr?language=pt

Resposta em JSON com o texto transcrito. Ideal para criar bots de transcrição de reuniões, podcasts ou assistentes de voz.

Otimizações e Boas Práticas para Produção

1. Limites de recursos (cgroups)

Evite que um container consuma toda a RAM da VPS:

docker run --memory="16g" --cpus="4" --gpus all ...

2. Volumes persistentes

Sempre mapeie volumes para os diretórios de modelos e dados:

volumes:
  - /mnt/ssd/models:/workspace/models  # modelos baixados
  - ./data:/workspace/data              # sua base de conhecimento

3. Segurança mínima

• Firewall: Libere apenas as portas necessárias (11434, 3000, 8188, 9000) via ufw.
• Autenticação: Para interfaces web, coloque atrás de um proxy reverso com autenticação básica (nginx + htpasswd).
• Atualizações: Use watchtower para atualizar containers automaticamente:

docker run -d --name watchtower -v /var/run/docker.sock:/var/run/docker.sock containrrr/watchtower

4. Pipeline de deploy com CI/CD

Integre com GitHub Actions para rebuild automático quando houver novos modelos ou configurações:

name: Deploy AI Stack

on:
  push:
    branches: [ main ]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Deploy via SSH
        uses: appleboy/ssh-action@v1.0.3
        with:
          host: ${{ secrets.VPS_HOST }}
          username: ${{ secrets.VPS_USER }}
          key: ${{ secrets.SSH_KEY }}
          script: |
            cd /docker/ai-stack
            docker compose pull
            docker compose up -d --remove-orphans

Caso de Uso Real: Assistente de Suporte Self-Hosted

Imagine um pequeno e-commerce que quer um chatbot baseado em sua base de conhecimento (PDFs de manual, FAQ, histórico de chamados).

Arquitetura:
1. Document Loader: Container que extrai texto dos PDFs.
2. Vector Database: ChromaDB ou Qdrant rodando em container.
3. LLM: Llama 3 8B via Ollama.
4. API Gateway: nginx roteando requisições.

Fluxo:
- Usuário faz pergunta.
- A pergunta é convertida em embedding (modelo all-MiniLM-L6-v2) e busca similaridade no vector DB.
- Contexto relevante + pergunta são enviados ao LLM.
- Resposta é gerada em ~3 segundos.

Custo estimado: $60/mês para uma instância VPS com T4 (Hetzner) + $0 de API externa. Comparado a $200/mês do ChatGPT Enterprise, a economia é significativa e os dados nunca saem do servidor.

Conclusão: O Futuro é Self-Hosted

Rodar aplicações de IA open source com Docker em uma VPS não é mais um exercício teórico. As ferramentas amadureceram, as GPUs se tornaram acessíveis (até instâncias spot) e a comunidade open source entrega qualidade comparável ou superior a soluções proprietárias.

Com os passos deste guia, você pode:
- Montar um chatbot privado com sua própria documentação.
- Gerar imagens sob demanda sem depender de APIs de terceiros.
- Transcrever reuniões inteiras em minutos.
- Escalar verticalmente adicionando mais GPUs ou distribuindo containers em cluster (Docker Swarm ou Kubernetes).

O próximo passo é explorar orquestração com Kubernetes e modelos multimodais (Llama 3.2 Vision, Whisper + LLM). O ecossistema está apenas começando — e seu VPS pode ser a plataforma de lançamento.

"A melhor API é aquela que você controla."

Compartilhe este guia com outros entusiastas de IA e Docker. E lembre-se: o único limite é o VRAM da sua GPU.

Gostou? Siga o blog para mais tutoriais práticos de engenharia de IA e infraestrutura. Deixe nos comentários qual aplicação você quer dockerizar em seguida.