Patrick Brandão

OpenClaw no Docker

Saudações.

Hoje vou ensinar vocês a instalar o OpenClaw (OC) em Docker.

Muita gente anda rodando o OC direto no host (instalar no computador, windows, mac, linux, direto na raiz do sistema) e isso pode resultar em catástrofes de segurança, vazamento de dados, instruções mal interpretadas que levam seus dados pro “beleleu“.

Isso é extremamente recomendável para manter seu agente de IA em um ambiente confinado onde ele só terá acesso ao que você explicitamente permitir.

A melhor tecnologia para isso são containers. O sistema de containers mais famoso e estável é o Docker.

Pré-requisitos (constam em outros artigos aqui do blog):

  • Instalação do Linux (Debian);
  • Internet no servidor (sua VPS ou host);
  • Docker CE instalado;
  • Possuir um domínio de DNS (exemplo: meudominio.com.br);

1 – O que é OpenClaw

Ele é um software, logo precisa rodar em algum computador! Vou abordar no capítulo 2 a instalação em Linux dentro de um container gerenciado pelo Docker.

O OpenClaw, anteriormente chamado de Clawbot e Moltbot, é um software de workspace de agentes de IA, um lugar onde vários agentes de IA são executados com informações, ferramentas e habilidades em comum.

Ele é capaz de rodar múltiplos agentes de IA conversacionais (chatbot) baseados em LLMs de mercado (OpenAI ChatGPT, Anthropic Claude, etc).

O grande diferencial do OpenClaw é entregar tudo isso pronto, sem toque de engenharia para colocar em funcionamento.

Do ponto de vista de um usuário leigo ele é um assistente de IA personalizado.

1.1 – Diferenciais

Seu principal diferencial em relação a agentes de IA feitos em sistemas como N8N, LangChain, Kestra ou Agentkit é o dinamismo de ferramentas e habilidades.

Um agente no OpenClaw consegue:

  • Treinar a si mesmo: a cada instrução ele monta um tutorial interno de capacidade que será usado sempre que uma tarefa dessa natureza for solicitada.
  • Memória optimizada: usando memória recente explicita e comprimindo conhecimento em memória de longo prazo (RAG) para pesquisa interna e uso de conhecimento quando uma tarefa a respeito do assunto é solicitada;
  • Capacidades plug-and-play: por meio de habilidades obtidas remotamente a partir de repositórios online onde uma comunidade enorme cria instruções para o agente realizar uma tarefa com perfeição e compartilha para os demais usarem.
  • Capacidades aprendidas: por meio de habilidades obtidas construídas localmente ele se torna capaz de fazer tarefas com muita precisão a medida que você o ensina, ensina as regras e exemplos de como agir.

1.2 – O que são skills

O suporte a SKILLs (habilidades) é o ponto forte do OpenClaw.

As SKILLs funcionam como “tools para obter prompts“.

Para leigos a explicação seria:

“Um botão que contem uma frase simples do que ele faz e quando você o aperta um manual de uso de um novo painel cai no seu colo, junto com o novo painel de botões”.

Essa “lista de botões de skills” ocupa pouco espaço na janela de contexto e permite que o agente saiba fazer muita coisa com poucas instruções iniciais e o conteúdo da SKILL não é incluída na memória do agente. Ele precisará apertar o botão toda vez que precisar se lembrar como fazer um trabalho específico e consultar na memória os pedidos e ações que ele tomou a respeito desse assunto no passado.

Uma SKILL é implementada a partir de uma pasta “./skill-NOMEHABILIDADE/” contendo um arquivo SKILL.md (documento em formato MarkDown) que instrui o agente como obter o poder que ele precisa para realizar uma tarefa específica.

A SKILL pode, opcionalmente, incluir software ou código-fonte, artefatos (documentos), guia de ferramentas e credenciais.

Uma SKILL de agenda de compromissos (skill-agenda) explica sua finalidade (frase explicativa pontual), as regras para agendar compromissos, como funciona a API de um software de controle de calendário, cadastro de compromissos, edição (reagendar), cancelamento de compromisso, avisos de lembrete e demais recursos de gestão de agenda. Bastaria criar o arquivo ./skill-agenda/SKILL.md com tudo isso.

1.3 – Cron Jobs

O OpenClaw implementa também um agendamento interno (Cron Jobs). Isso dispara o agente periodicamente e dá a ela a capacidade de estar sempre em funcionamento, uma espécie de “Agente em Loop infinito“.

O OpenClaw pode manipular seu próprio agendamento de disparo.

Se você pedir a ele fazer uma tarefa em uma data/hora futura ele agendará a própria execução criando um novo job. Ele será executado quando essa data chegar com um prompt específico para fazer o que você pediu (ele mesmo monta o prompt).

1.4 – O devorador de tokens

O ponto fraco do OpenClaw é o consumo de tokens.

Por ser um agente em execução constante ele aciona a API da LLM (IA) constantemente cada vez que é acordado, seja pare ver aconteceu algo que precisa de atenção ou para responder seus pedidos no chat.

Para usar uma LLM como o ChatGPT você é tarifado por Megatoken (MT).

Você precisará:

  • Fazer uma conta;
  • Cadastrar cartão de crédito;
  • Estar ciente que a cobrança é em DÓLARES AMERICANO : $1 + IOF, 1 dólar ~= 6 reais;
    • 100 dólares = ~600 reais;
    • 200 dólares = ~1.200 reais;
    • 400 dólares = ~2.400 reais;
    • 1.000 dólares = ~6.000 reais;
  • Comprar crédito pré-pago: $10 por exemplo;
  • Programar regárca automática: +$20 sempre ficar próximo a $1;
  • Limitar o orçamento mensal: nunca ultrapassar $300 (300 dólares = 1.800 reais);

Tome cuidado com o modelo que irá usar pois os tokens podem acabar em minutos ou horas no primeiro dia de uso.

Manter o OpenClaw rodando por meses se ter o capricho de usá-lo para tarefas bem específicas pode drenar uma quantidade expressiva de recursos financeiros.

1.5 – Escolha do modelo de LLM

Você terá que escolher o MODELO DE LLM que irá usar.

Recomendo escolher modelos com sufixo “-codex“, “-chat“, “-mini” e “-nano” por serem rápidos, baratos e conseguirem realizar a maioria dos trabalhos cotidianos.

Modelos baratos podem rodar o mês inteiro com $100 (100 dólares) mas podem ser burros para tarefas complexas.

Modelos caros são extremamente inteligentes, fiz uma pergunta para o modelo OpenAI ChatGPT-5-Pro-Thinking e ele demorou 15 minutos para responder e me cobrou 3 dólares pela resposta (15 reais).

Modelos chineses são tentadores, centavos de dólar por Megatoken, recomendo apenas se você não tem dados sensíveis.

1.6 – Usar LLM local – IA na própria máquina

A primeira coisa que todo mundo pensa após ler sobre o consumo de tokens é “e se eu rodar uma IA na minha máquina?“.

A ponto principal é a escolha da GPU.

Uma GPU com pelo menos 24G de VRAM pode rodar modelos locais como o gpt-oss-20b que tem inteligência razoável.

Você pode optar pelas seguintes abordagens:

  • Execução minimalista: rodar apenas 1 modelo que cabe na sua GPU;
  • Execução fatiada: modelos muito grandes podem rodar em uma GPU pequena usando técnicas de execução segmentada onde cada camada do modelo é processada, uma de cada vez, esse método é extremamente lento e pode demorar até horas para que um texto grande termine de ser gerado;
  • Cluster RDMA: equipamentos com suporte a RDMA (acesso remoto a RAM) e que possuem memória integrada (RAM principal é usada por CPU e GPU) podem formar clusters que entregam uma VRAM final muito grande, esse método é usado para criar cluster com Apple Mac Mini e rodar grandes modelos ou vários modelos menores ao mesmo tempo com boa velocidade de tokens por segundo;

1.7 – Servidor de IA da empresa

Um modelo superior como gpt-oss-120b seriam necessários pelo menos 140G de VRAM (7 placas de 20G ou 4 placas de 32G).

As variáveis a pensar para que sua empresa tenha IA própria são:

  • Hardware do servidor: um Servidor (Dell, HP, Supermicro) ou PC Gammer com as capacidades:
    • Corrente elétrica: fontes entre 1KWh a 8KWh (ou mais);
    • CPU: para gerenciar os softwares e mover dados entre periféricos, uns 12 núcleos mínimos, mínimo 2GHz de base, consumo de energia em torno de 300W por socket (2 a 4 sockets por servidor);
    • RAM: para carregar o modelo na RAM para enviar as camadas para as GPUs e gerenciar de tokens;
    • GPU: para rodar a inferência (processar janela de contexto nas camadas do modelo para gerar tokens);

Custos envolvidos:

  • Custo Servidor:
    • Servidor básico: R$ 12.000,00;
    • Servidor razoável: R$ 45.000,00;
  • Custo de GPU:
    • RTX A4500 20 GB: ~R$ 8.000,00
    • RTX 5090 32 GB: ~R$ 30.000,00
    • NVIDIA H100 80 GB: ~R$ 180.000,00
  • Custo de energia:
    • Precisa calcular o consumo do servidor, o consumo das placas e multiplicar pelo custo do KWA da região;
    • Precisa calcular o custo de contingência: geradores e baterias;
  • Custo de licenciamento:
    • Sistema operacional: costuma ser gratuito (Linux), se usar Linux Red Hat pode haver custo de licença;
    • Softwares de gestão: para montar um cluster HPC (High-Performance Computing) você precisará desenvolver ou adquirir sistemas prontos;
    • Softwares de inferência e API: são os sistemas que vão criar APIs HTTP para suas IAs semelhantes às APIs de mercado (padrão ChatGPT);
  • Custo de propriedade: considerar a aquisição, leasing ou financiamento
    • O servidor opera por 5 anos e pode ser vendido (-50% do valor);
    • As GPUs tem vida útil de 3 a 6 anos (-20% do valor);

2 – Preparativos no Docker

Uma vez que o Docker foi instalado, crie a rede e deixe o Traefik de prontidão.

2.1 – Rede Docker

Vou deixar dois exemplos, o primeiro apenas com IPv4, se você está em um ambiente neandertal ou paleolítico.

Rede Docker IPv4-Only
Bash
# Rede de containers
    # - Se ja existe, 
    if [ -d /sys/class/net/br-net-public ]; then
        echo "# Rede ja existe";
    else
        echo "# Criando rede docker IPv4-Only";
        # - Criar
        docker network create \
            -d bridge \
            \
            -o "com.docker.network.bridge.name"="br-net-public" \
            -o "com.docker.network.bridge.enable_icc"="true" \
            -o "com.docker.network.driver.mtu"="1500" \
            \
            --subnet 10.249.0.0/16 --gateway 10.249.255.254 \
            \
            network_public;
    fi;

2.2 – Instalando Traefik

O Traefik será nosso proxy-reverso para dar URLs públicas para o container.

Você precisará informar seu email para que o LetsEncrypt aceite gerar certificados e alerte de expirações e bloqueios.

Grave seu email no arquivo /etc/email para deixar o script abaixo 100% automático.

Bash
# Email do administrador do traefik
echo "seu-nome-ou-nick@meudominio.com.br" > /etc/email;

Rodando Traefik no Docker:

Bash
# Variaveis
    NAME=traefik-app;
    LOCAL=$NAME.intranet.br;
    JSONPATH="/etc/letsencrypt/acme.json";
    EMAIL="root@intranet.br";
    [ -f /etc/email ] && EMAIL=$(head -1 /etc/email);

# Imagem
    IMAGE=traefik:latest;
    docker pull $IMAGE;

# Diretorio de dados persistentes
    DATADIR=/storage/traefik-app;
    mkdir -p $DATADIR/letsencrypt;
    mkdir -p $DATADIR/logs;
    mkdir -p $DATADIR/config;

# Renovar/rodar:
    # (limitar a 8 nucleos: --cpus="8.0")
    docker rm -f $NAME 2>/dev/null;
    docker run \
        -d --restart=always \
        --name $NAME -h $LOCAL \
        --tmpfs /run:rw,noexec,nosuid,size=2m \
        --tmpfs /tmp:rw,noexec,nosuid,size=2m \
        --read-only \
        --memory=1g --memory-swap=1g \
        \
        --network network_public \
        --mac-address "02:a2:49:25:55:ff" \
        \
        -p 80:80 \
        -p 443:443 \
        \
        -v /var/run/docker.sock:/var/run/docker.sock:ro \
        -v $DATADIR/letsencrypt:/etc/letsencrypt \
        -v $DATADIR/config:/etc/traefik \
        -v $DATADIR/logs:/logs \
        \
        $IMAGE \
          \
          --global.checkNewVersion=false \
          --global.sendAnonymousUsage=false \
          \
          --api.insecure=true \
          \
          --log.level=INFO \
          --log.filePath=/logs/error.log \
          \
          --accessLog.filePath=/logs/access.log \
          \
          --entrypoints.web.address=:80 \
          --entrypoints.web.http.redirections.entryPoint.to=websecure \
          --entrypoints.web.http.redirections.entryPoint.scheme=https \
          --entrypoints.web.http.redirections.entryPoint.permanent=true \
          --entrypoints.websecure.address=:443 \
          \
          --providers.docker=true \
          --providers.file.directory=/etc/traefik \
          \
          --certificatesresolvers.letsencrypt.acme.email=$EMAIL \
          --certificatesresolvers.letsencrypt.acme.storage=$JSONPATH \
          --certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web;

Para acompanhar os logs do Traefik e observar problemas, use esse comando (abra uma nova tela de terminal):

Bash
# Acompanhar logs do Traefik:
DATADIR=/storage/traefik-app;
tail -f $DATADIR/logs/*;

3 – Preparativos para o OpenClaw

Preste bastante atenção agora. Todos os itens são vitais para o funcionamento.

Vou fazer uso da imagem Docker feita pelo usuário phioranex do github, o link dos fontes para construção do container estão no link https://github.com/phioranex/openclaw-docker

3.1 – FQDN – Nome de DNS

Dê um nome ao seu OpenClaw como “Atlas“, nome da pessoa ou empresa que fará uso do dele. Nome de DNS (FQDN) será:

  • atlas.meudominio.com.br

Aponte no domínio “meudominio.com.br” o nome “atlas” para o IPv4 (registro tipo A) da sua VPS, supondo que o IP da sua VPS seja 45.255.128.2, o registro ficará assim:

  • atlas.meudominio.com.br IN A 45.255.128.2

3.2 – Pasta para volume do container

Vamos criar uma pasta para ser o volume do container OpenClaw. Como estou criando um OpenClaw específico que chamarei de “Atlas“, a pasta será /storage/openclaw-atlas

Bash
# Diretorio do volume do OpenClaw "Atlas"
DATADIR="/storage/openclaw-atlas";

# - Diretorio especifico para o volume do Atlas
mkdir -p $DATADIR;
mkdir -p $DATADIR/.openclaw;
mkdir -p $DATADIR/.openclaw/workspace;
mkdir -p $DATADIR/.openclaw/agents/main/agent;

3.3 – Chaves de API e arquivos com chaves de API

Crie as chaves de API especificamente para o “Atlas” com orçamento limitado para que os custos não fujam do seu controle. Não rode vários OpenClaw compartilhando a mesma chave pois isso deixará você sem controle de qual OpenClaw está drenando tokens.

Você precisará obter chaves de API dos seguintes serviços:

Salve as chaves de API em arquivos dentro do volume. Estes arquivos não são lidos pelo OpenClaw diretamente mas nos ajudará a obter as chaves no script de setup do OpenClaw adiante.

Alerta de segurança – não deixe suas chaves de API vazar.

Troque a frase “SUA-CHAVE-DE-API-…-AQUI” pela chave gerada nos sites acima.

Bash
DATADIR="/storage/openclaw-atlas";

# Gravar chave da OpenAI para variavel OPENAI_API_KEY
echo "SUA-CHAVE-DE-API-OPENAI-AQUI"    > $DATADIR/.openai_key;

# Gravar chave da Anthropic para variavel ANTHROPIC_API_KEY
echo "SUA-CHAVE-DE-API-ANTHROPIC-AQUI" > $DATADIR/.anthropic_key;

# Gravar chave da Gemini para variavel GEMINI_API_KEY
echo "SUA-CHAVE-DE-API-GEMINI-AQUI"    > $DATADIR/.gemini_key;

# Gravar chave da xAI para variavel XAI_API_KEY
echo "SUA-CHAVE-DE-API-XAI-AQUI"       > $DATADIR/.xai_key;

Criar arquivo com chave da Anthropic Claude:

Bash
DATADIR="/storage/openclaw-atlas";

# Configuracao de acesso ao Anthropic Claude
(
    echo '{';
    echo '  "default": {';
    echo '    "anthropic": {';
    echo "    \"apiKey\": \"$ANTHROPIC_API_KEY\"";
    echo '    }';
    echo '  }';
    echo '}';
) > "$DATADIR/.openclaw/agents/main/agent/auth-profiles.json";

3.4 – Token de acesso privilegiado ao painel do OpenClaw

Esse token é MUITO importante e grante o acesso de administrador pelo navegador.

Alerta de segurança – não deixe esse código vazar.

Bash
# Gerar UUID v4 randomico para usar como token
cat /proc/sys/kernel/random/uuid  >  /storage/openclaw-atlas/.admin_token;

# Visualizar token gerado:
cat /storage/openclaw-atlas/.admin_token;

3.5 – API de acesso a BOT no Telegram

O Telegram é o melhor aplicativo para interagir com o OpenClaw por meio de Smartphone.

É importante que seu bot não seja revelado a terceiros pois tudo que é conversado por meio dele tem acesso ao seu agente.

Alerta de segurança – não revele o nome do bot ou o token dele.

Para gerar um token de bot de Telegram:

  • Acesse: https://web.telegram.org/ ou use Telegram Desktop;
  • Inicie uma conversa com o BotFather: @BotFather em https://telegram.me/BotFather
  • Envie a mensagem /newbot
  • Informe o nome do bot, algo como: Atlas_1829_bot (precisa terminar com “_bot”)
  • Copie o token do bot, algo parecido com:
    • 8432912345:ABCd1ef2hij3lmnoPQRs4tuVxzWyABc5DEF

Salvar o token de bot Telegram em arquivo no volume do OpenClaw Atlas:

Bash
DATADIR="/storage/openclaw-atlas";

# Gerar UUID v4 randomico para usar como token
echo "SEU-TOKEN-DO-BOT-TELEGRAM-AQUI"  > $DATADIR/.telegram_token;

# Visualizar token do telegram gravado:
cat $DATADIR/.telegram_token;

3.6 – Configuração inicial do OpenClaw

Vamos preencher a configuração inicial, execute esses comandos apenas na primeira vez, depois disso a edição deve ser feita pelo comando “onboard” que vou mostrar adiante.

Bash
# Obter token administrativo do OpenClaw Atlas
OPENCLAW_GATEWAY_TOKEN=$(head -1 /storage/openclaw-atlas/.admin_token);

# Obter token do telegram
TELEGRAM_BOT_TOKEN=$(head -1 /storage/openclaw-atlas/.telegram_token);

# Criar o arquivo de configuração inicial:
(
    echo '{';
    echo '  "gateway": {';
    echo '    "mode": "local",';
    echo '    "bind": "lan",';
    echo '    "port": 18789,';
    echo '    "controlUi": {';
    echo '      "enabled": true,';
    echo '      "allowInsecureAuth": true';
    echo '    },';
    echo '    "auth": {';
    echo '      "mode": "token",';
    echo "      \"token\": \"$OPENCLAW_GATEWAY_TOKEN\"";
    echo '    },';
    echo '    "trustedProxies": [';
    echo '      "10.127.0.0/16",';
    echo '      "172.16.0.0/12",';
    echo '      "192.168.0.0/16",';
    echo '      "127.0.0.0/8"';
    echo '    ]';
    echo '  },';
    echo '  "plugins": {';
    echo '    "entries": {';
    echo '      "telegram": {';
    echo '        "enabled": true';
    echo '      }';
    echo '    }';
    echo '  },';
    echo '  "channels": {';
    echo '    "telegram": {';
    echo '      "enabled": true,';
    echo "      \"botToken\": \"$TELEGRAM_BOT_TOKEN\"";
    echo '    }';
    echo '  },';
    echo '  "agents": {';
    echo '    "defaults": {';
    echo '      "workspace": "/home/node/.openclaw/workspace"';
    echo '    }';
    echo '  }';
    echo '}';
) > /storage/openclaw-atlas/.openclaw/openclaw.json;

3.7 – Obter imagem para o container Docker

É muito importante obter a imagem atualizada do OpenClaw. Sempre execute esse comando, se ele fizer download de uma nova versão você deverá destruir o container do OpenClaw “Atlas” e executá-lo novamente para usar a imagem atualizada.

Bash
# - Imagem Docker do container
IMAGE="ghcr.io/phioranex/openclaw-docker:latest";

# Baixar imagem atualizada
docker pull $IMAGE;

3.8 – Boot da configuração completa

Executando o comando onboard podemos completar as configurações do OpenClaw. Você pode executar esse comando no futuro se desejar mudar as configurações via terminal. O container abaixo é temporário, ou seja, não permanece após a conclusão da tarefa.

Bash
# Criar contenter TEMPORARIO para configuracoes

# Variaveis
# - Diretorio do volume onde a configuração será salva
DATADIR="/storage/openclaw-atlas";

# - Imagem Docker do container
IMAGE="ghcr.io/phioranex/openclaw-docker:latest";

# - Criar e rodar
docker run --rm -it \
    --network network_public \
    \
    -v $DATADIR:/home/node \
    \
    -e TZ=America/Sao_Paulo \
    -e HOME=/home/node \
    -e TERM=xterm-256color \
    -e NODE_ENV=production \
    -e OPENCLAW_SKIP_SERVICE_CHECK=true \
    \
    -w /app \
    --entrypoint node \
    $IMAGE \
        /app/dist/index.js onboard;

3.9 – Ajustar permissões no volume

Bash
# Diretorio do volume
DATADIR="/storage/openclaw-atlas";

# Garantir existencia arquivo de ENV do processo gateway
touch  $DATADIR/.openclaw/.env;

# Fixar permissoes e modos de acesso
chown  -R 1000:1000  $DATADIR;
chmod  -R 755        $DATADIR;
chmod  644           $DATADIR/.openclaw/openclaw.json;
chmod  600           $DATADIR/.openclaw/agents/main/agent/auth-profiles.json;

4 – Rodando o OpenClaw

Vamos rodar o OpenClaw de nosso serviço chamado “Atlas” no container openclaw-atlas.

4.1 – Criar container do serviço

Vamos rodar o gateway, o aplicativo do OpenClaw pronto para trabalhar pra sempre em suas tarefas:

Bash
# Variaveis

# - Nome do container
    NAME="openclaw-atlas";

# - Nome de DNS para acesso pelo navegador
    FQDN="atlas.meudominio.com.br";

# - Diretorio do volume onde a configuração será salva
    DATADIR="/storage/openclaw-atlas";

# - Imagem Docker do container
    IMAGE="ghcr.io/phioranex/openclaw-docker:latest";

# - Porta TCP/HTTP
    # - Porta externa para acesso direto
    PORT_OUTSIDE=18789;
    # - Porta interna do servico OpenClaw
    PORT_INSIDE=18789;

# - Limite de recursos
    CPU_LIMIT="4.0";
    RAM_LIMIT="4g";

# - Variaveis armazenadas em arquivos
    # - Funcao para ler primeira linha de arquivo
    _fget(){ head -1 "$1" 2>/dev/null; };

    # - Parametros do OpenClaw
    OPENCLAW_SKIP_SERVICE_CHECK=true;
    OPENCLAW_GATEWAY_TOKEN=$(_fget $DATADIR/.admin_token);

    # Chaves de API
    ANTHROPIC_API_KEY=$(_fget $DATADIR/.anthropic_key);
    OPENAI_API_KEY=$(_fget $DATADIR/.openai_key);
    GEMINI_API_KEY=$(_fget $DATADIR/.gemini_key);
    XAI_API_KEY=$(_fget $DATADIR/.xai_key);

# - Remover container atual (se existir):
    docker rm -f $NAME 2>/dev/null;

# - RUN - Criar e rodar container:
    docker run \
      -d --restart=always --name $NAME -h $NAME.intranet.br \
      \
      --cpus=$CPU_LIMIT --memory=$RAM_LIMIT --memory-swap=$RAM_LIMIT \
      --shm-size=1g \
      --tmpfs /run:rw,noexec,nosuid,size=1g \
      --tmpfs /tmp:rw,noexec,nosuid,size=1g \
      \
      --network network_public \
      -p $PORT_OUTSIDE:$PORT_INSIDE \
      \
      -v $DATADIR:/home/node \
      \
      -e TZ=$TZ \
      -e HOME=/home/node \
      -e TERM=xterm-256color \
      -e NODE_ENV=production \
      \
      -e OPENCLAW_SKIP_SERVICE_CHECK=$OPENCLAW_SKIP_SERVICE_CHECK \
      -e OPENCLAW_GATEWAY_TOKEN=$OPENCLAW_GATEWAY_TOKEN \
      -e ANTHROPIC_API_KEY=$ANTHROPIC_API_KEY \
      -e OPENAI_API_KEY=$OPENAI_API_KEY \
      -e GEMINI_API_KEY=$GEMINI_API_KEY \
      -e XAI_API_KEY=$XAI_API_KEY \
      \
      --label "traefik.enable=true" \
      --label "traefik.http.routers.$NAME.rule=Host(\`$FQDN\`)" \
      --label "traefik.http.routers.$NAME.entrypoints=web,websecure" \
      --label "traefik.http.routers.$NAME.tls=true" \
      --label "traefik.http.routers.$NAME.service=$NAME_GW" \
      --label "traefik.http.routers.$NAME.tls.certresolver=letsencrypt" \
      --label "traefik.http.services.$NAME.loadbalancer.server.port=$PORT_INSIDE" \
      \
      -w /app \
      --entrypoint node \
      $IMAGE \
          /app/dist/index.js gateway --bind lan --port $PORT_INSIDE;

4.2 – Primeiro acesso

O primeiro acesos pelo navegador deve ser feito com o token administrativo para que a sessão fique salva no seu navegador. URLs de acesso:

Bash
# Endereco de DNS para acesso pelo navegador
    FQDN="atlas.meudominio.com.br";

# Diretorio do volume do container:
    DATADIR="/storage/openclaw-atlas";

# - Obter token administrativo do container:
    TOKEN=$(head -1  $DATADIR/.admin_token);

# - Exibir URLs de acesso:
    (
        echo;
        echo "Acesso:";
        echo "        https://$FQDN/?token=$TOKEN";
        echo;
    );

4.3 – Ativar bot do Telegram

Para que o bot do telegram possa funcionar de dentro do aplicativo Telegram ou Telegram Desktop é preciso confirmar o código de acesso do bot no OpenClaw.

Abra uma conversa com seu bot do Telegram (envie um “oi”) que o código será exibido. Execute os comandos abaixo para informar o código ao OpenClaw:

Bash
# - Nome do container
    NAME="openclaw-atlas";

# Diretorio do volume do container:
    DATADIR="/storage/openclaw-atlas";

# - Obter token administrativo
    # - Funcao para ler primeira linha de arquivo
    TOKEN=$(head -1  $DATADIR/.admin_token);

# - Codigo do telegram, exemplo: W7A31XYZ
    TELEGRAM_CODE="COLOQUE-O-CODIGO-AQUI";

# - Confirmar codigo:
    CMD="node /app/dist/index.js";
    docker exec $NAME_GW $CMD pairing approve telegram $TELEGRAM_CODE;

4.4 – Liberar acesso a outros navegadores

A gestão web do OpenClaw requer liberação por token.

Bash
# - Nome do container
    NAME="openclaw-atlas";

# Diretorio do volume do container:
    DATADIR="/storage/openclaw-atlas";

# - Obter token administrativo
    TOKEN=$(head -1  $DATADIR/.admin_token);

# - Exibir comandos uteis:
    (
        CMD="node /app/dist/index.js";
        echo;
        echo "Comandos Úteis:";
        echo "Logs.....:  docker logs -f $NAME";
        echo "Devices..:  docker exec $NAME $CMD devices list";
        echo "Adicionar:  docker exec $NAME $CMD devices approve <id-aqui>";
        echo "Check....:  docker exec $NAME $CMD health --token $TOKEN";
        echo;
);

.

“A hipocrisia é uma homenagem que o vício presta à virtude“
François La Rochefoucauld


Terminamos por hoje!

Patrick Brandão, patrickbrandao@gmail.com