---
title: "Modo Offline Total: OpenClaw Sem Internet Nenhuma"
url: "https://openclaw.ia.br/local/offline-total/"
markdown_url: "https://openclaw.ia.br/local/offline-total.MD"
description: "Configure OpenClaw em ambientes sem internet. Baixe modelos antecipadamente, transfira via USB, rode 100% air-gapped. Para segurança máxima e compliance."
date: ""
author: ""
---

# Modo Offline Total: OpenClaw Sem Internet Nenhuma

Configure OpenClaw em ambientes sem internet. Baixe modelos antecipadamente, transfira via USB, rode 100% air-gapped. Para segurança máxima e compliance.


<div class="badges">
⏱ <strong>30 minutos</strong> ·  <strong>Avançado</strong> ·  <strong>Air-Gapped</strong> · ✈ <strong>Sem Internet</strong>
</div>

Para quando "100% local" não basta — você precisa de **zero conexão com internet**. Nenhuma porta aberta, nenhum DNS, nenhum pacote baixado na máquina de produção.

Este guia mostra como preparar tudo em uma máquina conectada e transferir para uma máquina offline (air-gapped).

<div class="tldr-box">

### TL;DR — 3 Fases

1. **Máquina COM internet:** Baixe Ollama, modelo, Node.js e OpenClaw
2. **Transfira** via USB, SD card ou rede interna
3. **Máquina SEM internet:** Instale tudo a partir dos arquivos locais

</div>

---

## Quando Usar

- **Compliance** — LGPD, GDPR, HIPAA exigem que dados não saiam da rede
- **Dados sensíveis** — Código proprietário, documentos confidenciais, dados médicos
- **Ambientes restritos** — Governo, militar, infraestrutura crítica
- **Trabalho em campo** — Locais sem internet (embarcações, áreas rurais, eventos)
- **Segurança máxima** — Zero superfície de ataque via rede

> **Dica:** Se você tem internet mas quer privacidade, o [Setup Simples](/local/simples/) é mais fácil. Este guia é para ambientes **realmente sem internet**.

---

## Arquitetura

```
FASE 1                    FASE 2              FASE 3
┌──────────────────┐      ┌──────┐      ┌──────────────────┐
│ MÁQUINA ONLINE   │      │      │      │ MÁQUINA OFFLINE  │
│                  │      │ USB  │      │                  │
│ Baixar:          │ ───► │  ou  │ ───► │ Instalar:        │
│ - Ollama binary  │      │ SD   │      │ - Ollama binary  │
│ - Modelo (3-9GB) │      │ Card │      │ - Modelo IA      │
│ - Node.js tar    │      │      │      │ - Node.js        │
│ - OpenClaw .tgz  │      └──────┘      │ - OpenClaw       │
└──────────────────┘                     │                  │
                                         │ Resultado:       │
                                         │ IA funcionando   │
                                         │ sem internet     │
                                         └──────────────────┘
```

---

## Fase 1: Na Máquina COM Internet

Vamos baixar tudo que precisamos. Use uma máquina com internet e o **mesmo sistema operacional** da máquina de destino (mesma arquitetura: x86_64 ou ARM64).

### 1.1 Criar pasta de transferência

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

### 1.2 Baixar Ollama

```bash
# Linux x86_64
curl -L https://ollama.com/download/ollama-linux-amd64 -o ollama

# Linux ARM64 (Raspberry Pi, etc)
curl -L https://ollama.com/download/ollama-linux-arm64 -o ollama

# macOS — baixe o .dmg do site
# https://ollama.com/download/mac

chmod +x ollama
```

### 1.3 Baixar modelo de IA

```bash
# Instale Ollama temporariamente para baixar o modelo
./ollama serve &
sleep 5

# Baixar modelo (escolha um)
./ollama pull llama3.2:3b      # 2GB — leve
# ./ollama pull llama3.1:8b    # 4.7GB — equilibrado
# ./ollama pull qwen2.5:7b     # 4.4GB — bom em português

# Parar o Ollama
pkill ollama

# Copiar os arquivos do modelo
cp -r ~/.ollama/models ./ollama-models/
```

### 1.4 Baixar Node.js

```bash
# Linux x86_64
curl -O https://nodejs.org/dist/v24.0.0/node-v24.0.0-linux-x64.tar.xz

# Linux ARM64
curl -O https://nodejs.org/dist/v24.0.0/node-v24.0.0-linux-arm64.tar.xz

# macOS ARM64 (M1/M2/M3)
curl -O https://nodejs.org/dist/v24.0.0/node-v24.0.0-darwin-arm64.tar.gz
```

> **Nota:** Verifique a versão mais recente em [nodejs.org/download](https://nodejs.org/en/download/)

### 1.5 Baixar OpenClaw

```bash
# Empacotar OpenClaw para instalação offline
npm pack openclaw
# Isso cria: openclaw-x.x.x.tgz
```

### 1.6 Verificar pacote completo

```bash
ls -lh ~/openclaw-offline/
# Deve ter:
# ollama               (~100MB)
# ollama-models/       (2-9GB dependendo do modelo)
# node-v24.x.x-*.tar   (~30MB)
# openclaw-x.x.x.tgz   (~5MB)
```

---

## Fase 2: Transferir

Copie a pasta inteira `~/openclaw-offline/` para a mídia de transferência:

```bash
# Para USB (ajuste /dev/sdX e ponto de montagem)
cp -r ~/openclaw-offline/ /media/usb/

# Para um pendrive já montado
cp -r ~/openclaw-offline/ /mnt/pendrive/
```

**Tamanho total:** 2-10GB dependendo do modelo escolhido.

> **Segurança:** Se estiver transferindo para ambiente classificado, considere criptografar o USB com LUKS:
> ```bash
> # Na máquina online
> sudo cryptsetup luksFormat /dev/sdX1
> sudo cryptsetup open /dev/sdX1 usb_crypt
> sudo mkfs.ext4 /dev/mapper/usb_crypt
> sudo mount /dev/mapper/usb_crypt /mnt/usb
> cp -r ~/openclaw-offline/ /mnt/usb/
> ```

---

## Fase 3: Na Máquina SEM Internet

Conecte o USB e monte:

```bash
# Montar USB
sudo mount /dev/sdX1 /mnt/usb
cd /mnt/usb/openclaw-offline/
```

### 3.1 Instalar Node.js

```bash
# Extrair Node.js para /usr/local
sudo tar xf node-v24.0.0-linux-x64.tar.xz -C /usr/local --strip-components=1

# Verificar
node --version   # v24.x.x
npm --version    # 10.x.x
```

### 3.2 Instalar Ollama

```bash
# Copiar binário
sudo cp ollama /usr/local/bin/ollama
sudo chmod +x /usr/local/bin/ollama

# Criar usuário do serviço
sudo useradd -r -s /bin/false -m -d /usr/share/ollama ollama

# Copiar modelos
sudo mkdir -p /usr/share/ollama/.ollama/
sudo cp -r ollama-models/ /usr/share/ollama/.ollama/models/
sudo chown -R ollama:ollama /usr/share/ollama/.ollama/

# Criar serviço systemd
sudo tee /etc/systemd/system/ollama.service > /dev/null << 'EOF'
[Unit]
Description=Ollama Service
After=network-online.target

[Service]
User=ollama
Group=ollama
ExecStart=/usr/local/bin/ollama serve
Restart=always
RestartSec=3
Environment="OLLAMA_HOST=0.0.0.0"
Environment="HOME=/usr/share/ollama"

[Install]
WantedBy=default.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable ollama
sudo systemctl start ollama
```

### 3.3 Verificar Ollama

```bash
ollama list
# Deve listar o modelo copiado (llama3.2:3b)

ollama run llama3.2:3b "Olá! Estou offline?"
# Deve responder normalmente
```

### 3.4 Instalar OpenClaw

```bash
# Instalar a partir do pacote local
sudo npm install -g ./openclaw-*.tgz

# Verificar
openclaw --version
```

### 3.5 Configurar

```bash
openclaw onboard --install-daemon
# Escolha: Ollama como provider
# Modelo: llama3.2:3b
# Canal: o que preferir
```

Ou configure manualmente:

```yaml
# ~/clawd/config.yaml
agents:
  defaults:
    model:
      primary: "ollama/llama3.2:3b"

ollama:
  baseUrl: "http://localhost:11434"
  timeout: 120
```

### 3.6 Verificar

```bash
openclaw gateway status
# Deve mostrar: running
```

Envie uma mensagem de teste. Se respondeu — **funciona 100% sem internet**.

<div class="success-box">

###  Air-Gapped e Funcionando!

Seu assistente IA roda sem nenhuma conexão com internet. Nenhum dado pode sair.

</div>

---

## Desmontar USB e Bloquear

Depois de instalar tudo, remova o USB e (opcionalmente) bloqueie portas USB:

```bash
# Desmontar
sudo umount /mnt/usb

# Opcional: Desabilitar USB (segurança extrema)
# echo 'blacklist usb-storage' | sudo tee /etc/modprobe.d/block-usb.conf
# sudo update-initramfs -u
```

---

## Atualizações em Ambiente Offline

Para atualizar, repita o processo:

1. Na máquina online: `npm pack openclaw` + `ollama pull modelo-novo`
2. Transfira via USB
3. Na máquina offline: `sudo npm install -g ./openclaw-*.tgz`

**Frequência recomendada:** Uma vez por mês para patches de segurança.

---

## Segurança Adicional

### Firewall

```bash
# Bloquear TODO tráfego externo (só permitir loopback)
sudo iptables -P INPUT DROP
sudo iptables -P FORWARD DROP
sudo iptables -P OUTPUT DROP
sudo iptables -A INPUT -i lo -j ACCEPT
sudo iptables -A OUTPUT -o lo -j ACCEPT
sudo iptables-save | sudo tee /etc/iptables/rules.v4
```

### Logs de auditoria

```bash
# Habilitar auditoria de acesso ao OpenClaw
sudo auditctl -w /home/$USER/clawd/ -p rwxa -k openclaw_access
```

### Criptografia de disco

Para máxima segurança, use criptografia full-disk (LUKS) na máquina offline. Se alguém roubar o hardware, os dados ficam protegidos.

---

## Para Empresas: Compliance

| Regulação | Como o Air-Gap Atende |
|-----------|----------------------|
| **LGPD** | Dados pessoais nunca saem do servidor controlado |
| **GDPR** | Sem transferência internacional de dados |
| **HIPAA** | Informações de saúde permanecem on-premise |
| **SOC 2** | Perímetro de segurança claramente definido |

> **Dica:** Documente o processo de air-gap como parte do seu relatório de compliance. O fato de que nenhum dado pode sair da rede é um diferencial forte.

---

## Troubleshooting

<details>
<summary><strong>Ollama não encontra o modelo copiado</strong></summary>

Verifique a estrutura de pastas:
```bash
ls -la /usr/share/ollama/.ollama/models/
# Deve ter: blobs/ e manifests/
```

Se a estrutura está diferente, copie novamente:
```bash
sudo rm -rf /usr/share/ollama/.ollama/models/
sudo cp -r /mnt/usb/openclaw-offline/ollama-models/ /usr/share/ollama/.ollama/models/
sudo chown -R ollama:ollama /usr/share/ollama/.ollama/
sudo systemctl restart ollama
```
</details>

<details>
<summary><strong>npm install falha offline (dependências)</strong></summary>

O `npm pack` empacota o OpenClaw mas pode precisar de dependências nativas. Na máquina online, faça:
```bash
# Instalar todas as dependências offline
npm install --global-style openclaw@latest
cd $(npm root -g)/openclaw
npm pack
```
Isso garante que todas as dependências estão incluídas.
</details>

<details>
<summary><strong>Arquitetura incompatível</strong></summary>

Se a máquina online é x86_64 mas a offline é ARM64 (ou vice-versa), baixe os binários para a arquitetura correta:
```bash
# Verificar arquitetura da máquina de destino
uname -m
# x86_64 = amd64, aarch64 = arm64
```
</details>

---

## Próximos Passos

- [**Setup Simples** → Tem internet? Este é mais fácil](/local/simples/)
- [**Docker Compose** → Containers gerenciados](/local/docker-compose/)
- [**Raspberry Pi 5** → Servidor dedicado 24/7](/local/raspberry-pi/)
- [IA com Privacidade: Por Que Importa →](/blog/privacidade-ia-local-openclaw/)
- [Guia de Segurança 2026 →](/blog/guia-seguranca-openclaw-2026/)
- [Voltar ao hub de guias locais →](/local/)