---
title: "Stack Docker: OpenClaw + Ollama em Containers (100% Local)"
url: "https://openclaw.ia.br/local/docker-compose/"
markdown_url: "https://openclaw.ia.br/local/docker-compose.MD"
description: "Docker Compose com OpenClaw e Ollama rodando juntos em containers. Setup robusto, reproduzível, fácil de gerenciar. Zero dependência de cloud."
date: ""
author: ""
---

# Stack Docker: OpenClaw + Ollama em Containers (100% Local)

Docker Compose com OpenClaw e Ollama rodando juntos em containers. Setup robusto, reproduzível, fácil de gerenciar. Zero dependência de cloud.


<div class="badges">
⏱ <strong>20 minutos</strong> ·  <strong>Intermediário</strong> ·  <strong>Docker</strong> ·  <strong>100% Local</strong>
</div>

OpenClaw + Ollama rodando juntos em containers Docker. **Um `docker compose up` e tudo sobe.** Mais robusto que a instalação direta, fácil de atualizar, reinicia automaticamente.

> **Primeira vez com Docker?** Recomendamos o [Setup Simples](/local/simples/) — sem Docker, sem complicação. Volte aqui quando quiser mais controle.

<div class="tldr-box">

### TL;DR — Só os Comandos

```bash
# 1. Crie a pasta e o docker-compose.yml (conteúdo abaixo)
mkdir -p ~/openclaw-local && cd ~/openclaw-local

# 2. Suba tudo
docker compose up -d

# 3. Baixe o modelo de IA
docker exec ollama ollama pull llama3.2:3b

# 4. Configure o OpenClaw
docker exec -it openclaw openclaw onboard
```

</div>

---

## Por Que Docker?

| Vantagem | Descrição |
|----------|-----------|
| **Isolamento** | Nada instalado no sistema. Remove tudo com `docker compose down -v` |
| **Reproduzível** | Mesmo `docker-compose.yml` funciona em qualquer máquina |
| **Auto-restart** | Reinicia sozinho se cair ou se o PC reiniciar |
| **GPU passthrough** | Suporte nativo a GPUs NVIDIA via Container Toolkit |
| **Atualizações** | `docker compose pull && docker compose up -d` — pronto |

---

## Requisitos

- **Docker** 20.10+ com Docker Compose v2+
- **RAM:** 8GB+ (16GB recomendado)
- **Disco:** 10GB+ livres
- **GPU (opcional):** NVIDIA com [Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/)

### Instalar Docker

**Ubuntu/Debian:**
```bash
curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER
# Faça logout e login novamente
```

**macOS/Windows:** Baixe o [Docker Desktop](https://www.docker.com/products/docker-desktop)

---

## Passo 1: Criar o docker-compose.yml

```bash
mkdir -p ~/openclaw-local && cd ~/openclaw-local
```

Crie o arquivo `docker-compose.yml`:

```yaml
# docker-compose.yml — OpenClaw + Ollama 100% Local
version: '3.8'

services:
  # Motor de IA local
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    restart: unless-stopped
    volumes:
      - ollama-data:/root/.ollama
    ports:
      - "11434:11434"
    # Descomente para GPU NVIDIA:
    # deploy:
    #   resources:
    #     reservations:
    #       devices:
    #         - driver: nvidia
    #           count: 1
    #           capabilities: [gpu]

  # OpenClaw Gateway
  openclaw:
    image: node:22-slim
    container_name: openclaw
    restart: unless-stopped
    depends_on:
      - ollama
    volumes:
      - openclaw-workspace:/app/workspace
      - openclaw-config:/app/config
    environment:
      - NODE_ENV=production
      - OLLAMA_HOST=http://ollama:11434
    working_dir: /app
    command: >
      sh -c "
        npm install -g openclaw@latest &&
        openclaw gateway start --foreground
      "
    ports:
      - "3434:3434"

volumes:
  ollama-data:      # Modelos de IA ficam aqui
  openclaw-workspace:  # Memória e configurações
  openclaw-config:     # Config do OpenClaw
```

---

## Passo 2: Subir os Containers

```bash
docker compose up -d
```

Aguarde 1-2 minutos para o OpenClaw instalar na primeira vez. Acompanhe:

```bash
# Ver logs do OpenClaw
docker compose logs -f openclaw

# Ver logs do Ollama
docker compose logs -f ollama
```

---

## Passo 3: Baixar o Modelo de IA

```bash
# Baixar modelo (dentro do container Ollama)
docker exec ollama ollama pull llama3.2:3b
```

### Modelos recomendados

```bash
# Leve e rápido (2GB) — para PCs com 8GB RAM
docker exec ollama ollama pull llama3.2:3b

# Equilibrado (4.7GB) — para PCs com 16GB RAM
docker exec ollama ollama pull llama3.1:8b

# Alta qualidade (8.9GB) — para PCs com GPU
docker exec ollama ollama pull qwen2.5:14b
```

---

## Passo 4: Configurar OpenClaw

```bash
docker exec -it openclaw openclaw onboard
```

Quando perguntar o provider:
- **Provider:** Ollama
- **URL do Ollama:** `http://ollama:11434` (nome do serviço Docker, não localhost!)
- **Modelo:** `llama3.2:3b`
- **Canal:** Escolha WhatsApp, Telegram, etc.

### Configuração manual

Se preferir editar diretamente:

```bash
docker exec -it openclaw sh -c 'cat > /app/workspace/config.yaml << EOF
agents:
  defaults:
    model:
      primary: "ollama/llama3.2:3b"

ollama:
  baseUrl: "http://ollama:11434"
  timeout: 120
EOF'

# Reiniciar para aplicar
docker compose restart openclaw
```

> **Importante:** Use `http://ollama:11434` (nome do serviço Docker) e **não** `http://localhost:11434`. Os containers se comunicam pelo nome do serviço na rede Docker.

---

## Passo 5: Testar

Envie uma mensagem pelo canal configurado:

> "Olá! Quem é você?"

Verificar status:
```bash
docker exec openclaw openclaw gateway status
```

<div class="success-box">

###  Stack Local Funcionando!

OpenClaw + Ollama rodando em containers. Auto-restart, isolamento, zero cloud.

</div>

---

## GPU NVIDIA (Opcional)

Se tem uma GPU NVIDIA, a inferência fica **5-10x mais rápida**:

### 1. Instalar NVIDIA Container Toolkit

```bash
# Ubuntu/Debian
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | \
  sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
  sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker
```

### 2. Ativar no docker-compose.yml

Descomente o bloco `deploy` no serviço `ollama`:

```yaml
  ollama:
    image: ollama/ollama:latest
    # ... restante igual ...
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
```

### 3. Recriar container

```bash
docker compose up -d ollama
```

Verifique que a GPU está sendo usada:
```bash
docker exec ollama ollama ps
# Deve mostrar "gpu" no processador
```

---

## Gerenciamento Diário

```bash
# Ver status
docker compose ps

# Ver logs em tempo real
docker compose logs -f

# Parar tudo
docker compose stop

# Reiniciar
docker compose restart

# Atualizar imagens
docker compose pull && docker compose up -d

# Remover tudo (dados mantidos nos volumes)
docker compose down

# Remover tudo INCLUINDO dados
docker compose down -v
```

---

## Backup e Restauração

### Fazer backup

```bash
# Backup dos dados do OpenClaw
docker run --rm -v openclaw-local_openclaw-workspace:/data \
  -v $(pwd):/backup alpine tar czf /backup/openclaw-backup.tar.gz -C /data .

# Backup dos modelos (grande!)
docker run --rm -v openclaw-local_ollama-data:/data \
  -v $(pwd):/backup alpine tar czf /backup/ollama-backup.tar.gz -C /data .
```

### Restaurar

```bash
docker run --rm -v openclaw-local_openclaw-workspace:/data \
  -v $(pwd):/backup alpine sh -c "cd /data && tar xzf /backup/openclaw-backup.tar.gz"
```

---

## Auto-Iniciar com o Sistema

O `restart: unless-stopped` no compose já garante reinício automático. Para iniciar o Docker no boot:

```bash
# Linux
sudo systemctl enable docker

# macOS: Ative no Docker Desktop > Settings > General > "Start Docker Desktop when you log in"
```

---

## Troubleshooting

<details>
<summary><strong>OpenClaw não conecta ao Ollama</strong></summary>

O problema mais comum é usar `localhost` em vez do nome do serviço Docker:

```yaml
# ERRADO
ollama:
  baseUrl: "http://localhost:11434"

# CORRETO
ollama:
  baseUrl: "http://ollama:11434"
```

Verifique a rede Docker:
```bash
docker exec openclaw curl -s http://ollama:11434/api/version
```
</details>

<details>
<summary><strong>Container reinicia em loop</strong></summary>

Veja os logs para identificar o erro:
```bash
docker compose logs openclaw --tail 50
docker compose logs ollama --tail 50
```

Causas comuns:
- Porta 3434 ou 11434 já em uso no host
- Memória insuficiente (Ollama precisa de RAM para o modelo)
</details>

<details>
<summary><strong>Modelo lento no container</strong></summary>

- Verifique se GPU está ativada: `docker exec ollama ollama ps`
- Aumente memória do container (Docker Desktop > Settings > Resources)
- Use modelo menor: `docker exec ollama ollama pull phi3:mini`
</details>

<details>
<summary><strong>Espaço em disco cheio</strong></summary>

```bash
# Ver uso por volume
docker system df -v

# Limpar imagens não usadas
docker image prune -a

# Remover modelos grandes do Ollama
docker exec ollama ollama rm nome-do-modelo
```
</details>

---

## Próximos Passos

- [**Setup Simples** → Sem Docker, mais fácil](/local/simples/)
- [**Offline Total** → Sem internet nenhuma](/local/offline-total/)
- [**Raspberry Pi 5** → Servidor 24/7 dedicado](/local/raspberry-pi/)
- [Docker: Guia Completo →](/tutoriais/docker/)
- [Voltar ao hub de guias locais →](/local/)