Homelab

Como Montar um Homelab Linux: Guia Completo de Infraestrutura em Casa

setembro 1, 2026 · 16 min de leitura · Luiz Seabra

Como Montar um Homelab Linux: Guia Completo de Infraestrutura em Casa

Montar um homelab Linux é uma jornada que combina prática, aprendizado e organização. O objetivo é disponibilizar um ambiente controlado onde possamos testar, desenvolver e rodar serviços pessoais sem depender de provedores externos em nuvem, garantindo total soberania sobre nossos dados e nossa infraestrutura.

Este guia cobre todos os passos necessários, desde a definição de objetivos e escolha de hardware até a implantação de containers, redes, armazenamento em NAS, políticas de backup e endurecimento de segurança. Ao final, você terá um ambiente robusto e pronto para hospedar Gitea, Portainer, Grafana, Nextcloud, Pi-hole e muito mais.

O que você vai aprender

• Planejar objetivos, orçamento e hardware ideal para o seu homelab
• Configurar rede residencial (roteador, switch, VLANs e DNS com Pi-hole)
• Compreender e implementar sistemas de armazenamento (SSD vs HDD, ZFS, mergerfs)
• Instalar e utilizar KVM/QEMU como hypervisor base
• Deployar Docker, Docker Compose e Traefik como proxy reverso com HTTPS automático
• Construir um NAS caseiro compartilhando arquivos via NFS e SMB
• Avaliar quando utilizar K3s (Kubernetes) versus manter o Docker Compose
• Implementar a regra de backup 3-2-1 com BorgBackup e rotinas cron
• Endurecer a segurança com firewall UFW, WireGuard VPN e boas práticas de engenharia

Pré-requisitos

• No mínimo 8 GB de RAM (16 GB ou mais altamente recomendado)
• CPU com suporte a virtualização de hardware (Intel VT-x ou AMD-V)
• SSD de 250 GB para o sistema operacional e metadados de containers
• Conexão de internet estável e acesso físico/IP local ao servidor
• Conhecimento básico de comandos Linux, permissões e edição de arquivos via terminal

Conceitos fundamentais

Por que escolher Linux para o Homelab?

O ecossistema Linux fornece total transparência e controle sobre o kernel, os pacotes e a rede. Diferente de sistemas proprietários, o Linux consome menos recursos de hardware (sem overhead de interface gráfica em servidores) e suporta nativamente tecnologias essenciais como KVM, containers OCI, iptables/nftables e sistemas de arquivos avançados.

Virtualização (KVM/QEMU) vs Containers (Docker)

Compreender o limite entre VMs e containers é crucial para o planejamento de recursos:
– KVM/QEMU: Cada máquina virtual possui seu próprio sistema operacional convidado e kernel dedicado. Oferece isolamento completo e segurança forte, ideal para testar distribuições diferentes ou rodar serviços críticos que exigem recursos exclusivos.
– Docker: Os containers compartilham o kernel do host Linux. Iniciam em frações de segundo e consomem pouca memória RAM, sendo perfeitos para microsserviços, aplicações web, bancos de dados e ferramentas de monitoramento.

Quando adotar Kubernetes (K3s)?

Kubernetes é o padrão da indústria para orquestração de containers, mas introduz complexidade operacional significativa (etcd, manifests, ingress controllers, coredns). No homelab:
– Use Docker Compose se: Você roda até 20-30 serviços em um único host, prioriza simplicidade e quer manutenibilidade descomplicada.
– Use K3s se: Seu objetivo é aprender Kubernetes para o mercado de trabalho, se planeja expandir para múltiplos nós físicos, ou se precisa de recursos avançados de auto-cura e rolling updates.

Preparação do ambiente

1. Definir objetivos e escopo

Antes de comprar qualquer hardware, responda: O que este homelab precisa rodar hoje? E daqui a um ano?
– Se o foco é aprender Docker e Linux básico, um Mini-PC com processador Intel N100 e 8GB de RAM é suficiente e consome pouca energia (cerca de 10W a 15W em idle).
– Se o objetivo inclui serviços corporativos locais (Git, Nextcloud, Plex, servidores de CI/CD), procure um desktop reaproveitado com um Intel Core i5 de gerações recentes ou um servidor de entrada, com pelo menos 16GB de RAM e 500GB de SSD.

2. Escolha da rede e conectividade

A rede é a espinha dorsal do homelab. Um design ruim gera gargalos difíceis de depurar.
– Endereçamento IP Fixo: Configure reservas de IP no seu roteador DHCP para garantir que o servidor mantenha sempre o mesmo endereço (ex: 192.168.1.100).
– Segmentação com VLANs: Se tiver um switch gerenciável, separe a rede em VLANs distintas para isolar IoT, convidados e o homelab de produção.
– DNS Sinkhole (Pi-hole): Instale o Pi-hole em um container na rede para bloquear anúncios em nível de DNS e acelerar a navegação de toda a casa, além de permitir o mapeamento de domínios internos.

3. Armazenamento e Sistema de Arquivos

A performance de E/S de disco é o primeiro gargalo em homelabs.
– SSD/NVMe para SO e Bancos de Dados: O sistema operacional, diretórios /var/lib/docker e volumes de bancos de dados (PostgreSQL, MySQL) devem residir obrigatoriamente em SSDs para evitar latência alta de IOPS.
– HDD para Bulk Storage (Arquivos/Mídia): Para armazenamento em larga escala, utilize HDDs mecânicos em configuração de redundância (RAID por software ou ZFS).
– ZFS vs mergerfs: ZFS oferece integridade de dados contra bitrot, mas exige memória ECC/RAM dedicada. O mergerfs combinado com SnapRAID é uma alternativa excelente para quem mistura discos de tamanhos diferentes sem perder flexibilidade.

4. Estrutura de diretórios padrão

Crie uma árvore limpa para seus arquivos de configuração:

mkdir -p ~/homelab/{docker,vm,nas,ansible,terraform,backups,docs}
cd ~/homelab

Explicação: Padronizar diretórios evita perda de arquivos de configuração e facilita a automação com Ansible ou scripts de backup.

Resultado esperado: Árvore de diretórios criada com sucesso em ~/homelab.

Tutorial passo a passo

Etapa 1 – Instalação e configuração inicial do Ubuntu Server

Instancie ou instale o Ubuntu Server 24.04 LTS seguindo o assistente padrão. Após o primeiro boot, verifique o ambiente:

# Verificar arquitetura e kernel
uname -m && uname -r
# Verificar espaço em disco
df -h

Explicação: Validamos que o kernel suporta os módulos necessários e checamos o particionamento inicial.

Resultado esperado: Saída indicando arquitetura x86_64 (ou aarch64) e kernel Linux atualizado.

Etapa 2 – Hardening de SSH (Chaves Ed25519)

Acesse sua máquina e configure o acesso seguro:

# Gerar par de chaves Ed25519 no cliente
ssh-keygen -t ed25519 -C "admin@homelab" -f ~/.ssh/homelab_ed25519

# Copiar para o servidor
ssh-copy-id -i ~/.ssh/homelab_ed25519.pub admin@192.168.1.100

# No servidor, editar configuração SSH
sudo nano /etc/ssh/sshd_config

Adicione ou ajuste as diretivas:

PasswordAuthentication no
PubkeyAuthentication yes
PermitRootLogin no
MaxAuthTries 3

Reinicie o serviço e configure o firewall UFW:

sudo systemctl restart ssh
sudo apt install -y ufw
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 22/tcp
sudo ufw enable

Explicação: Desativar senhas e login de root elimina mais de 90% das tentativas automatizadas de invasão via força bruta.

Resultado esperado: UFW ativo bloqueando conexões não autorizadas, SSH aceitando apenas autenticação por chave criptográfica.

Etapa 3 – Instalação do Hypervisor KVM/QEMU

Verifique se a virtualização está ativa no CPU e instale os pacotes libvirt:

# Verificar suporte a virtualização de hardware
grep -E '(vmx|svm)' /proc/cpuinfo
ls -l /dev/kvm

# Instalar KVM e ferramentas de gestão
sudo apt install -y qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils virtinst
sudo systemctl enable --now libvirtd
sudo usermod -aG kvm,libvirt $USER

Explicação: O módulo KVM transforma o kernel Linux em um hypervisor bare-metal. O libvirt gerencia as VMs de forma padronizada.

Resultado esperado: /dev/kvm presente e serviço libvirtd ativo.

Etapa 4 – Instalação do Docker Engine Oficial

Remova pacotes conflitantes e adicione o repositório oficial da Docker Inc:

sudo apt remove -y docker docker-engine docker.io containerd runc
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -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 "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo systemctl enable --now docker
sudo usermod -aG docker $USER

Explicação: Garantimos a instalação da versão atualizada do Docker Engine com suporte a Buildx e Docker Compose V2.

Resultado esperado: Comandos docker --version e docker compose version retornando versões válidas.

Etapa 5 – Configuração do Traefik Reverse Proxy com SSL Automático

Crie a estrutura para o Traefik:

mkdir -p ~/homelab/docker/traefik/data
touch ~/homelab/docker/traefik/data/acme.json
chmod 600 ~/homelab/docker/traefik/data/acme.json

Crie o docker-compose.yml do Traefik:

version: "3.9"
services:
  traefik:
    image: traefik:v3.0
    container_name: traefik
    command:
      - "--api.insecure=true"
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.websecure.address=:443"
      - "--certificatesresolvers.myresolver.acme.tlschallenge=true"
      - "--certificatesresolvers.myresolver.acme.email=admin@homelab.local"
      - "--certificatesresolvers.myresolver.acme.storage=/letsencrypt/acme.json"
    ports:
      - "80:80"
      - "443:443"
      - "8080:8080"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./data/acme.json:/letsencrypt/acme.json
    restart: unless-stopped

cd ~/homelab/docker/traefik
docker compose up -d

Explicação: O Traefik age como porta de entrada única (portas 80 e 443), roteando o tráfego HTTP/HTTPS para os containers internos com base em regras de Host.

Resultado esperado: Traefik rodando e painel de API acessível em http://localhost:8080.

Etapa 6 – Implementação de um NAS Simples (NFS e Samba)

Instale os pacotes de compartilhamento:

sudo apt install -y nfs-kernel-server samba
sudo mkdir -p /srv/nas/compartilhado
sudo chown -R nobody:nogroup /srv/nas/compartilhado
sudo chmod 2775 /srv/nas/compartilhado

Configure o NFS em /etc/exports:

/srv/nas/compartilhado 192.168.1.0/24(rw,sync,no_subtree_check,no_root_squash)

Aplique as exportações:

sudo exportfs -ra
sudo systemctl restart nfs-kernel-server

Explicação: O protocolo NFS permite que outras VMs e servidores na sua rede local montem pastas do host com alta performance.

Resultado esperado: Compartilhamento NFS ativo e acessível por clientes na rede local.

Etapa 7 – Rotina de Backup Automatizado com BorgBackup

Instale o Borg e crie o repositório local:

sudo apt install -y borgbackup
borg init -e repokey-blake2 ~/homelab/backups/borg-repo

Crie o script de automação ~/homelab/scripts/backup.sh:

#!/bin/bash
set -e
REPO=~/homelab/backups/borg-repo
DATE=$(date +%Y-%m-%d_%H-%M-%S)

export BORG_PASSPHRASE="sua_senha_segura_aqui"

borg create -v --stats \
  $REPO::$DATE \
  /etc \
  /home/admin/homelab/docker \
  --exclude '*.tmp'

# Rotação de backups antigos (mantém últimos 7 diários, 4 semanais)
borg prune -v --list $REPO \
  --keep-daily=7 \
  --keep-weekly=4 \
  --keep-monthly=6

Torne o script executável e adicione ao crontab:

chmod +x ~/homelab/scripts/backup.sh
(crontab -l 2>/dev/null; echo "0 3 * * * /home/admin/homelab/scripts/backup.sh >> /home/admin/homelab/backups/backup.log 2>&1") | crontab -

Explicação: O Borg realiza deduplicação de dados, economizando espaço em disco e garantindo cópias incrementais eficientes.

Resultado esperado: Script agendado para rodar diariamente às 03:00 da manhã.

LABORATÓRIO — Montagem Reproduzível do Homelab

Abaixo apresentamos o arquivo docker-compose.yml consolidado que reúne a pilha essencial de serviços do homelab (Portainer para gestão, Gitea para código, Pi-hole para DNS/bloqueio, Prometheus + Grafana para monitoramento e Nextcloud para nuvem pessoal), todos integrados ao Traefik.

Crie o arquivo em ~/homelab/docker/compose/docker-compose.yml:

version: "3.9"

services:
  portainer:
    image: portainer/portainer-ce:latest
    container_name: portainer
    ports:
      - "9000:9000"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - portainer_data:/data
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.portainer.rule=Host(`portainer.homelab.local`)"
      - "traefik.http.routers.portainer.entrypoints=web"
      - "traefik.http.services.portainer.loadbalancer.server.port=9000"
    restart: unless-stopped

  gitea:
    image: gitea/gitea:latest
    container_name: gitea
    environment:
      - USER_UID=1000
      - USER_GID=1000
    ports:
      - "3000:3000"
      - "2222:22"
    volumes:
      - gitea_data:/data
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.gitea.rule=Host(`gitea.homelab.local`)"
      - "traefik.http.routers.gitea.entrypoints=web"
      - "traefik.http.services.gitea.loadbalancer.server.port=3000"
    restart: unless-stopped

  pihole:
    image: pihole/pihole:latest
    container_name: pihole
    environment:
      TZ: "America/Sao_Paulo"
      WEBPASSWORD: "admin_homelab_secure"
    ports:
      - "53:53/tcp"
      - "53:53/udp"
      - "8080:80"
    volumes:
      - pihole_etc:/etc/pihole
      - pihole_dnsmasq:/etc/dnsmasq.d
    cap_add:
      - NET_ADMIN
    restart: unless-stopped

  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    restart: unless-stopped

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3001:3000"
    volumes:
      - grafana_data:/var/lib/grafana
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
    depends_on:
      - prometheus
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.grafana.rule=Host(`grafana.homelab.local`)"
      - "traefik.http.routers.grafana.entrypoints=web"
      - "traefik.http.services.grafana.loadbalancer.server.port=3000"
    restart: unless-stopped

volumes:
  portainer_data:
  gitea_data:
    external: false
  pihole_etc:
  pihole_dnsmasq:
  prometheus_data:
  grafana_data:

Para subir o ambiente completo:

cd ~/homelab/docker/compose
docker compose up -d

Explicação: Este arquivo sobe todos os serviços core do homelab de forma declarativa, garantindo persistência via volumes nomeados e roteamento automático via Traefik.

Resultado esperado: O resultado esperado é que todos os containers iniciem sem erros de porta e respondam aos domínios locais configurados.

Troubleshooting: problemas comuns e como resolver

Sintoma: O host não reinicializa após atualização do kernel (Kernel Panic ou tela preta)

Possível causa

• Falta de espaço na partição /boot devido a kernels antigos acumulados.

Diagnóstico

df -h /boot
dpkg -l | grep linux-image

Solução

# Remover kernels antigos não utilizados com segurança
sudo apt autoremove --purge

Prevenção

• Configurar rotina para limpeza de kernels antigos ou habilitar unattended-upgrades com expurgo.

Sintoma: Falta de memória RAM repentina (OOM Killer encerra containers)

Possível causa

• Ausência de espaço de swap ou consumo excessivo de memória por banco de dados/Nextcloud.

Diagnóstico

free -h
dmesg | grep -i oom
docker stats --no-stream

Solução

# Criar swap file de 4GB se necessário
sudo fallocate -l 4G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

Prevenção

• Definir limites de memória (deploy.resources.limits.memory) nos arquivos Docker Compose para cada container.

Sintoma: Rede instável ou perda de pacotes no servidor

Possível causa

• Driver de placa de rede Realtek sem suporte nativo perfeito no kernel ou cabo danificado.

Diagnóstico

ip link
ethtool eth0
dmesg | grep -i eth

Solução

# Atualizar firmware de rede linux-firmware
sudo apt update && sudo apt install --only-upgrade linux-firmware

Prevenção

• Priorizar placas de rede Intel (ex: Intel I225/I226) ao adquirir hardware para homelab.

Sintoma: Disco cheio por acúmulo de logs do Docker

Possível causa

• Rotação de logs do Docker desativada no daemon.json.

Diagnóstico

du -sh /var/lib/docker/containers/*

Solução

Editar /etc/docker/daemon.json:

{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
  }
}

Reiniciar o Docker:

sudo systemctl restart docker

Prevenção

• Manter limites de tamanho de log globais configurados no Docker daemon.

Segurança

A segurança de um homelab deve ser tratada com o mesmo rigor de um ambiente de produção empresarial:
– Isolamento de acesso: Nunca exponha portas diretamente no roteador (port forwarding indiscriminado). Utilize uma VPN WireGuard para acessar seus serviços remotamente.
– Princípio do menor privilégio: Não execute containers como root a menos que seja estritamente necessário (como o Pi-hole que precisa manipular regras de rede).
– Atualizações consistentes: Mantenha pacotes do sistema atualizados com patches de segurança semanais.

Boas práticas

• Documentação viva: Mantenha um arquivo README.md dentro de cada pasta de projeto explicando variáveis de ambiente e dependências.
• Infrastructure as Code (IaC): Versionar todos os seus compose files e scripts em um repositório Git (pode ser o seu Gitea local).
• Testes de Restore: Um backup que nunca foi testado para restauração é apenas um arquivo ocupando espaço. Simule uma restauração mensalmente.

Conclusão

Montar um homelab Linux é um dos investimentos de tempo mais recompensadores para qualquer profissional de TI, DevOps ou engenheiro de infraestrutura. Ao centralizar seus serviços em casa, você ganha autonomia, privacidade e domínio prático sobre Linux, virtualização, redes e automação.

Comece pequeno com uma única máquina e um punhado de containers, evoluindo incrementalmente para arquiteturas mais resilientes à medida que sua curva de aprendizado avança.

Perguntas frequentes

Posso reaproveitar um notebook antigo para homelab?

Sim! Notebooks antigos são excelentes porque já vêm com bateria integrada (funcionando como nobreak básico) e tela para troubleshooting de emergência. Apenas remova a tampa traseira para garantir boa ventilação e desative a suspensão ao fechar a tampa.

Vale a pena usar Raspberry Pi no homelab?

Raspberry Pi 4 ou 5 são ótimos para serviços leves como Pi-hole, Home Assistant ou VPN, mas sofrem gargalos de E/S por utilizarem cartões SD ou USB limitado para armazenamento pesado, além de arquitetura ARM que pode incompatibilizar com algumas imagens Docker x86.

Como acesso meus serviços de fora de casa com segurança?

A melhor prática é instalar um container WireGuard ou Tailscale no seu homelab. Assim, você cria uma VPN privada criptografada para sua rede doméstica sem precisar abrir portas vulneráveis na internet pública.

Próximo passo

Agora que você domina Como Montar Um Homelab Linux, o próximo passo lógico da nossa trilha de aprendizado é continuar desenvolvendo suas habilidades.

→ Continue: Laboratório de Infraestrutura Completo

Artigos relacionados

Estes artigos complementam o conteúdo apresentado: