Dark n BlackMulti-canal

Servidor Local Dell — Atlas e Ledger

Jun 2026·Concluído·multi-canalhomelabubuntudockertailscalecaddyatlasledger
Progresso geral57 / 99 tarefas (58%)
Runbook completo para transformar o Dell Inspiron 15 Gamer em servidor local privado. Ubuntu Server + Docker + Caddy + Tailscale. Sem abrir porta no roteador.

Servidor Local Brutalista — Dell Inspiron | Atlas + Ledger

Tutorial completo para transformar um Dell Inspiron 15 Gamer antigo em um servidor local privado com Ubuntu Server, Docker, Caddy, Tailscale, domínios locais e deploy automático via GitHub Actions.

O plano certo

00 / Objetivo

O objetivo é transformar o Dell Inspiron 15 Gamer em um servidor local para dois projetos pessoais: Atlas e Ledger. O servidor ficará privado, preferencialmente sem nenhuma porta aberta no roteador. Ele poderá acessar a internet para consumir APIs, mas não ficará exposto publicamente.

PC principal / celular
        ↓
atlas.local / ledger.local
        ↓
DNS local ou hosts
        ↓
Notebook Dell servidor — 192.168.0.50
        ↓
Caddy reverse proxy
        ↓
Containers Docker
        ├── Atlas
        └── Ledger

**

Modo LAN

Acessa os projetos quando estiver na mesma rede Wi-Fi/cabo da casa.

http://atlas.local

http://ledger.local

**

Modo 5G

Acessa de fora usando Tailscale, sem abrir porta no roteador.

http://atlas.home.arpa ou IP Tailscale

http://ledger.home.arpa ou IP Tailscale

⚠️ Regra de ouro: não faça port forwarding no roteador para portas 80, 443, 22, 3000, 5432 ou 6379. Para uso pessoal, o caminho mais seguro é rede local + Tailscale.

Verificação do notebook

01 / Pré-check

Antes de instalar Ubuntu, valide se o notebook aguenta ficar ligado por longos períodos sem virar uma torradeira.

Checklist físico

Teste rápido no Windows atual

Antes de formatar, você pode abrir o PowerShell e verificar algumas informações:

systeminfo
wmic diskdrive get model,status,size
wmic memorychip get capacity,speed
wmic cpu get name

💡 Critério prático: se o notebook tiver SSD, 8 GB+ RAM e não superaquecer, ele serve muito bem para Atlas e Ledger como projetos pessoais.

Criar pendrive Ubuntu

02 / Instalação

Baixe a ISO do Ubuntu Server LTS e grave no pendrive. No Windows, a forma mais simples é usar o Rufus.

Passos no Windows

⚠️ Atenção: na instalação, você vai escolher o disco do notebook. Confirme duas vezes antes de apagar.

Boot pela BIOS

03 / Dell BIOS

Em notebooks Dell, normalmente você usa F12 para abrir o menu de boot e F2 para entrar na BIOS.

Boot pelo pendrive

Configurações úteis na BIOS

ConfiguraçãoValor sugeridoPor quê
Boot ModeUEFIMais moderno e recomendado para Ubuntu atual.
Secure BootDesativar se der erroUbuntu costuma funcionar com Secure Boot, mas alguns setups antigos dão dor de cabeça.
AC Recovery / Power On AC AttachPower OnFaz o notebook ligar sozinho quando a energia voltar, se a BIOS suportar.
Wake on LANAtivar opcionalmentePermite acordar/ligar pela rede em alguns cenários.

💡 Nem todo Inspiron tem todas as opções. Se não existir auto power on, ainda dá para usar, só não ligará sozinho após queda total de energia.

Instalar Ubuntu Server

04 / Sistema

O Ubuntu Server é mais leve e estável para esse uso do que uma instalação desktop cheia de interface gráfica.

Configuração recomendada no instalador

✅ Meta desta fase: notebook ligando direto no Ubuntu Server, com usuário sudo e SSH disponível.

Primeiro boot

05 / Pós-instalação

Depois de instalar, atualize o sistema, instale ferramentas básicas e confirme o IP atual do servidor.

Atualizar o Ubuntu

sudo apt update && sudo apt upgrade -y
sudo apt install -y curl wget git unzip htop nano vim ufw ca-certificates gnupg lsb-release apt-transport-https software-properties-common

Ver IP do servidor

ip a

Procure algo como:

inet 192.168.0.50/24

Acessar do seu PC Windows via SSH

No PowerShell do seu PC principal:

ssh willian@192.168.0.50

IP fixo local

06 / Rede

O melhor caminho é reservar o IP do notebook no roteador, usando o MAC address. Assim você evita mexer no Netplan do Ubuntu.

Opção A — Recomendado: reserva DHCP no roteador

  1. Entre no painel do roteador.
  2. Procure por DHCP Reservation, Address Reservation ou IP/MAC Binding.
  3. Selecione o notebook servidor.
  4. Reserve o IP 192.168.0.50.
  5. Reinicie a conexão ou reinicie o notebook.

Descobrir MAC address no Ubuntu

ip link

Procure a interface cabeada, geralmente enp..., e o campo link/ether.

Opção B — IP fixo direto no Ubuntu

Use apenas se seu roteador não permitir reserva DHCP.

ls /etc/netplan
sudo nano /etc/netplan/00-installer-config.yaml

Exemplo de configuração. Ajuste interface, gateway e DNS conforme sua rede:

network:
  version: 2
  ethernets:
    enp3s0:
      dhcp4: no
      addresses:
        - 192.168.0.50/24
      routes:
        - to: default
          via: 192.168.0.1
      nameservers:
        addresses:
          - 1.1.1.1
          - 8.8.8.8

Aplicar:

sudo netplan try
sudo netplan apply

⚠️ Cuidado: se configurar Netplan errado, você pode perder SSH e precisar corrigir direto no notebook. Por isso a reserva DHCP no roteador é mais segura.

Rodar como servidor

07 / Energia

Notebook como servidor precisa ignorar tampa fechada, não suspender por inatividade e tentar religar quando a energia voltar.

Desativar suspensão ao fechar a tampa

sudo nano /etc/systemd/logind.conf

Altere ou adicione:

HandleLidSwitch=ignore
HandleLidSwitchExternalPower=ignore
HandleLidSwitchDocked=ignore
IdleAction=ignore

Reinicie o serviço:

sudo systemctl restart systemd-logind

Desativar sleep/suspend/hibernate

sudo systemctl mask sleep.target suspend.target hibernate.target hybrid-sleep.target

Validar status

systemctl status sleep.target suspend.target hibernate.target hybrid-sleep.target

Auto power on após queda de energia

Entre na BIOS com F2 e procure por:

Configure como Power On, se existir.

Instalar Docker

08 / Runtime

Docker Compose será o centro do setup. Cada aplicação roda em container, e o Caddy roteia os domínios locais para o container certo.

Remover versões conflitantes

for pkg in docker.io docker-doc docker-compose docker-compose-v2 podman-docker containerd runc; do sudo apt remove -y $pkg || true; done

Adicionar repositório oficial do Docker

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor --yes -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo ${UBUNTU_CODENAME:-$VERSION_CODENAME}) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update

Instalar Docker Engine + Compose plugin

sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Permitir usar Docker sem sudo

sudo usermod -aG docker $USER
newgrp docker

Testar

docker run hello-world
docker compose version

Domínios locais

09 / Proxy

O Caddy será o reverse proxy local. Você acessa atlas.local, e ele encaminha internamente para o container do Atlas. O mesmo vale para ledger.local.

atlas.local  ─┐
             ├── DNS local → 192.168.0.50 → Caddy → atlas:3000
ledger.local ─┘                         └→ ledger:3000

💡 Sobre .local: funciona em muitos ambientes, mas pode conflitar com mDNS/Bonjour. O domínio tecnicamente mais seguro para rede doméstica é .home.arpa. Por isso o guia configura os dois.

Criar estrutura base

sudo mkdir -p /srv/homelab/{proxy,apps,backups,scripts}
sudo chown -R $USER:$USER /srv/homelab
cd /srv/homelab

Criar Caddyfile

nano /srv/homelab/proxy/Caddyfile

Conteúdo:

{
  auto_https off
}

atlas.local, atlas.home.arpa {
  reverse_proxy atlas:3000
}

ledger.local, ledger.home.arpa {
  reverse_proxy ledger:3000
}

Configurar DNS local — opção simples no Windows

Abra o Bloco de Notas como Administrador e edite:

C:\Windows\System32\drivers\etc\hosts

Adicione:

192.168.0.50 atlas.local
192.168.0.50 ledger.local
192.168.0.50 atlas.home.arpa
192.168.0.50 ledger.home.arpa

Limpar cache DNS no Windows

ipconfig /flushdns

Configurar DNS local — melhor opção para todos os dispositivos

Para funcionar no celular, você precisa que o roteador ou um DNS interno resolva esses nomes. As melhores opções são:

Entrada DNS desejada

NomeTipoDestino
atlas.localA192.168.0.50
ledger.localA192.168.0.50
atlas.home.arpaA192.168.0.50
ledger.home.arpaA192.168.0.50

Tailscale no 5G

10 / Acesso remoto

Tailscale cria uma rede privada entre seus dispositivos. Seu celular no 5G não entra literalmente no Wi-Fi da sua casa, mas consegue acessar o notebook como se estivesse numa rede privada compartilhada.

Celular no 5G
    ↓
App Tailscale conectado
    ↓
Tailnet privada
    ↓
Notebook Dell com Tailscale
    ↓
Atlas / Ledger

Instalar Tailscale no Ubuntu Server

curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up

O comando vai exibir um link. Abra no navegador, faça login e autorize o servidor.

Ver IP Tailscale do servidor

tailscale ip -4
tailscale status

Instalar Tailscale no celular

Firewall liberando LAN + Tailscale

sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow from 192.168.0.0/24
sudo ufw allow in on tailscale0
sudo ufw enable
sudo ufw status verbose

MagicDNS

No painel do Tailscale, ative MagicDNS. Isso permite acessar dispositivos pelo nome dentro da tailnet. Exemplo:

http://dell-server:80

Para usar exatamente atlas.local no 5G, você precisaria de DNS local acessível pela tailnet ou configurar Split DNS no Tailscale. Para evitar atrito, o setup mais estável é:

CenárioEndereço sugerido
PC na rede localhttp://atlas.local e http://ledger.local
Celular no Wi-Fi com DNS localhttp://atlas.local e http://ledger.local
Celular no 5G com Tailscale simpleshttp://IP_TAILSCALE ou http://dell-server
Celular no 5G com Split DNShttp://atlas.home.arpa e http://ledger.home.arpa

✅ Recomendação prática: comece com Tailscale + IP do servidor. Depois refinamos para Split DNS se você quiser uma experiência 100% domínio também no 5G.

Atlas e Ledger

11 / Aplicações

A forma mais simples de operar é manter um docker-compose.yml raiz em /srv/homelab com Caddy, Atlas, Ledger e serviços compartilhados como Postgres e Redis.

Estrutura sugerida

/srv/homelab
├── docker-compose.yml
├── .env
├── proxy
│   └── Caddyfile
├── apps
│   ├── atlas
│   └── ledger
├── backups
└── scripts

Clonar projetos

cd /srv/homelab/apps
git clone git@github.com:SEU_USUARIO/atlas.git atlas
git clone git@github.com:SEU_USUARIO/ledger.git ledger

💡 Se você ainda não usa SSH no GitHub: também pode clonar via HTTPS no começo. Para deploy automático, SSH fica mais confortável depois.

Arquivo /srv/homelab/.env

POSTGRES_USER=homelab
POSTGRES_PASSWORD=troque_essa_senha
POSTGRES_DB=homelab
REDIS_PASSWORD=troque_essa_senha_tambem

ATLAS_PORT=3000
LEDGER_PORT=3000

Arquivo /srv/homelab/docker-compose.yml

services:
  caddy:
    image: caddy:2
    container_name: homelab-caddy
    restart: unless-stopped
    ports:
      - "80:80"
    volumes:
      - ./proxy/Caddyfile:/etc/caddy/Caddyfile:ro
      - caddy_data:/data
      - caddy_config:/config
    depends_on:
      - atlas
      - ledger
    networks:
      - homelab

  atlas:
    build:
      context: ./apps/atlas
      dockerfile: Dockerfile
    container_name: atlas
    restart: unless-stopped
    env_file:
      - ./.env
    expose:
      - "3000"
    depends_on:
      - postgres
      - redis
    networks:
      - homelab

  ledger:
    build:
      context: ./apps/ledger
      dockerfile: Dockerfile
    container_name: ledger
    restart: unless-stopped
    env_file:
      - ./.env
    expose:
      - "3000"
    depends_on:
      - postgres
      - redis
    networks:
      - homelab

  postgres:
    image: postgres:16
    container_name: homelab-postgres
    restart: unless-stopped
    environment:
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: ${POSTGRES_DB}
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - homelab

  redis:
    image: redis:7-alpine
    container_name: homelab-redis
    restart: unless-stopped
    command: redis-server --requirepass ${REDIS_PASSWORD}
    volumes:
      - redis_data:/data
    networks:
      - homelab

networks:
  homelab:
    driver: bridge

volumes:
  caddy_data:
  caddy_config:
  postgres_data:
  redis_data:

Subir tudo

cd /srv/homelab
docker compose up -d --build
docker compose ps

Ver logs

docker compose logs -f caddy
docker compose logs -f atlas
docker compose logs -f ledger

Testar no servidor

curl -I http://localhost
curl -I -H "Host: atlas.local" http://localhost
curl -I -H "Host: ledger.local" http://localhost

Testar no PC

curl -I http://atlas.local
curl -I http://ledger.local

Deploy automático por commit

12 / Deploy

A melhor estratégia para seu caso é usar GitHub Actions com self-hosted runner instalado no próprio notebook. Assim o notebook se conecta ao GitHub por saída HTTPS e executa o deploy localmente. Você não abre SSH para a internet.

Você no PC
  ↓ git push
GitHub
  ↓ dispara workflow
Self-hosted runner no notebook
  ↓
git pull / docker compose build / docker compose up -d
  ↓
Atlas e Ledger atualizados

⚠️ Segurança: use self-hosted runner apenas em repositórios privados ou controlados. Não permita que pull requests de desconhecidos executem código no seu notebook.

Instalar dependências do runner

sudo apt install -y libicu-dev jq

Criar usuário dedicado para runner

sudo adduser github-runner
sudo usermod -aG docker github-runner

Adicionar runner no GitHub

  1. Abra o repositório no GitHub.
  2. Vá em Settings.
  3. Vá em Actions → Runners.
  4. Clique em New self-hosted runner.
  5. Escolha Linux x64.
  6. Copie os comandos oficiais que o GitHub mostrar.

Instalar como serviço

Depois de configurar o runner, entre na pasta do runner e rode:

sudo ./svc.sh install github-runner
sudo ./svc.sh start
sudo ./svc.sh status

Script de deploy local

Crie:

nano /srv/homelab/scripts/deploy.sh

Conteúdo:

#!/usr/bin/env bash
set -euo pipefail

cd /srv/homelab

echo "[deploy] Atualizando Atlas..."
cd /srv/homelab/apps/atlas
git fetch origin
git reset --hard origin/main

echo "[deploy] Atualizando Ledger..."
cd /srv/homelab/apps/ledger
git fetch origin
git reset --hard origin/main

echo "[deploy] Rebuild e restart..."
cd /srv/homelab
docker compose up -d --build

echo "[deploy] Limpando imagens antigas..."
docker image prune -f

echo "[deploy] Status final:"
docker compose ps

Permissão:

chmod +x /srv/homelab/scripts/deploy.sh

Workflow GitHub Actions — Atlas

No repo do Atlas, crie .github/workflows/deploy-local.yml:

name: Deploy Atlas Local

on:
  push:
    branches:
      - main
  workflow_dispatch:

jobs:
  deploy:
    runs-on: self-hosted

    steps:
      - name: Deploy no servidor local
        run: /srv/homelab/scripts/deploy.sh

Workflow GitHub Actions — Ledger

No repo do Ledger, crie o mesmo arquivo:

name: Deploy Ledger Local

on:
  push:
    branches:
      - main
  workflow_dispatch:

jobs:
  deploy:
    runs-on: self-hosted

    steps:
      - name: Deploy no servidor local
        run: /srv/homelab/scripts/deploy.sh

💡 Por que o script atualiza os dois projetos? Porque você terá um compose único em /srv/homelab. Quando fizer push no Atlas ou no Ledger, o servidor sincroniza os dois e sobe o stack inteiro. É simples e robusto para uso pessoal.

Deploy mais refinado opcional

Depois, se quiser, você pode separar em:

Não confie no disco

13 / Backup

Notebook antigo pode morrer sem avisar. Mesmo sendo projeto pessoal, faça backup do banco e dos volumes.

Backup simples do Postgres

Crie:

nano /srv/homelab/scripts/backup-postgres.sh

Conteúdo:

#!/usr/bin/env bash
set -euo pipefail

BACKUP_DIR="/srv/homelab/backups/postgres"
DATE="$(date +%Y-%m-%d_%H-%M-%S)"

mkdir -p "$BACKUP_DIR"

cd /srv/homelab

docker compose exec -T postgres pg_dumpall -U "$POSTGRES_USER" > "$BACKUP_DIR/postgres_$DATE.sql"

gzip "$BACKUP_DIR/postgres_$DATE.sql"

find "$BACKUP_DIR" -type f -name "*.gz" -mtime +14 -delete

echo "Backup criado em $BACKUP_DIR/postgres_$DATE.sql.gz"

Permissão:

chmod +x /srv/homelab/scripts/backup-postgres.sh

Agendar no cron

crontab -e

Adicionar backup diário às 03:00:

0 3 * * * /srv/homelab/scripts/backup-postgres.sh >> /srv/homelab/backups/backup.log 2>&1

Backup externo

Além do backup local, copie periodicamente para:

Monitoramento

14 / Operação

Você precisa saber se os containers estão vivos, se o servidor esquentou demais e se o disco está saudável.

Instalar sensores

sudo apt install -y lm-sensors
sudo sensors-detect
sensors

Ver uso de disco

df -h
docker system df

Ver recursos em tempo real

htop

Adicionar Uptime Kuma opcional

No docker-compose.yml, adicione:

uptime-kuma:
    image: louislam/uptime-kuma:1
    container_name: uptime-kuma
    restart: unless-stopped
    volumes:
      - uptime_kuma_data:/app/data
    expose:
      - "3001"
    networks:
      - homelab

No final dos volumes:

uptime_kuma_data:

No Caddyfile:

kuma.local, kuma.home.arpa {
  reverse_proxy uptime-kuma:3001
}

Não expor é estratégia

15 / Segurança

Para seu caso, a melhor segurança é simples: não abrir porta no roteador, usar firewall e acessar remotamente só via Tailscale.

Firewall base

sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow from 192.168.0.0/24
sudo ufw allow in on tailscale0
sudo ufw enable
sudo ufw status verbose

SSH apenas na LAN/Tailscale

Com a regra acima, SSH será acessível apenas pela rede local ou Tailscale, desde que não exista port forwarding no roteador.

Não expor banco

No compose, prefira expose em vez de ports para Postgres e Redis. Assim eles ficam acessíveis só entre containers.

Boas práticas

Atualização semanal simples

sudo apt update && sudo apt upgrade -y
docker compose pull
docker compose up -d
docker image prune -f

Troubleshooting

16 / Problemas comuns

Não consigo acessar atlas.local

  1. Teste o IP direto: http://192.168.0.50.
  2. Teste o hosts/DNS: ping atlas.local.
  3. Limpe DNS no Windows: ipconfig /flushdns.
  4. Teste Caddy no servidor: curl -I -H "Host: atlas.local" http://localhost.
  5. Veja logs: docker compose logs -f caddy.

Docker não sobe

cd /srv/homelab
docker compose config
docker compose logs -f
docker compose ps

Runner do GitHub não executa

sudo ./svc.sh status
journalctl -u actions.runner* -f

Tailscale não conecta

tailscale status
tailscale netcheck
sudo systemctl status tailscaled

Notebook dorme ao fechar a tampa

grep -E "HandleLidSwitch|IdleAction" /etc/systemd/logind.conf
systemctl status systemd-logind
systemctl status sleep.target suspend.target hibernate.target hybrid-sleep.target

Reiniciar tudo com segurança

cd /srv/homelab
docker compose down
docker compose up -d --build
docker compose ps

Checklist de validação

17 / Final

Quando todos esses itens estiverem marcados, seu servidor local estará pronto para uso real no dia a dia.

✅ Resultado final: Atlas e Ledger rodando em servidor local privado, com acesso bonito por domínio, acesso remoto seguro via Tailscale e deploy por commit sem expor sua rede.

          Refs / Fontes oficiais
          Referências