Como montar um home lab para aprender DevOps sem gastar muito

Montar um home lab para aprender DevOps pode parecer um investimento alto à primeira vista, mas com planejamento e escolhas inteligentes é possível construir um ambiente completo de aprendizado gastando muito pouco — ou até nada. Este artigo mostra o caminho prático para criar seu laboratório pessoal usando hardware modesto, software livre e créditos gratuitos de nuvem, tudo alinhado à proposta da série Temas — Lista Final (1200 temas).

1. Planejamento e definição de objetivos para o home lab

Antes de instalar qualquer software, defina claramente quais habilidades DevOps você quer praticar. As áreas mais comuns incluem:

  • CI/CD: pipelines automatizados de build, teste e deploy
  • Containers: Docker, Docker Compose e orquestração básica
  • Infraestrutura como código (IaC): Terraform, Ansible, Vagrant

O escopo mínimo viável para começar é: um servidor Linux, Docker Engine, um sistema de versionamento (Git) e uma ferramenta de CI/CD. Ferramentas mais complexas como Kubernetes, service mesh ou monitoramento distribuído podem ficar para uma segunda fase.

Ferramentas gratuitas e open source substituem perfeitamente soluções pagas:

Necessidade Solução paga Alternativa gratuita
Versionamento GitHub Enterprise GitLab CE, Gitea
CI/CD CircleCI, Travis CI Jenkins, Drone CI
IaC Terraform Cloud (pago) Terraform CLI + backend local
Monitoramento Datadog, New Relic Prometheus + Grafana

2. Hardware acessível e reutilização de equipamentos antigos

Você não precisa comprar servidores novos. Opções reais de baixo custo:

  • PC ou notebook antigo: um computador com 4 GB de RAM e processador dual-core já roda Ubuntu Server e alguns containers
  • Raspberry Pi 4/5: excelente para serviços leves (DNS, Git, monitoramento) com consumo elétrico mínimo
  • Máquinas virtuais no próprio computador: VirtualBox ou VMware Player permitem simular múltiplos servidores sem hardware extra
  • VPS baratos: provedores como Hetzner, Contabo ou Hostinger oferecem VPS por menos de R\$ 20/mês
  • Créditos gratuitos em nuvem: AWS Free Tier (12 meses), Oracle Cloud Always Free (recursos permanentes) e Google Cloud Free Tier

Exemplo de configuração mínima funcional:

Hardware: Notebook antigo com 8 GB RAM, SSD 120 GB, processador i5 de 3ª geração
SO: Ubuntu Server 22.04 LTS (sem interface gráfica)
Serviços: Docker Engine, GitLab CE (container), Jenkins (container)
Custo: R$ 0 (equipamento já disponível)

3. Instalação e configuração do sistema operacional e virtualização

Distribuições Linux leves e estáveis para home lab:

  • Ubuntu Server: ampla documentação, suporte a longo prazo (LTS)
  • Debian: estável, consome poucos recursos
  • Alpine Linux: extremamente leve, ideal para containers e dispositivos com pouca RAM

Hypervisors gratuitos para criar múltiplos servidores virtuais:

  • Proxmox VE: completo, baseado em KVM, interface web, suporte a containers LXC
  • Hyper-V Server: versão gratuita da Microsoft, boa integração com Windows
  • KVM + virt-manager: nativo no Linux, performático e maduro

Gerenciamento de containers com Docker:

# Instalação do Docker Engine no Ubuntu Server
sudo apt update
sudo apt install docker.io docker-compose-v2 -y
sudo systemctl enable --now docker
sudo usermod -aG docker $USER

# Teste rápido
docker run hello-world

Para um ambiente com múltiplos serviços, use Docker Compose:

# docker-compose.yml básico
version: '3.8'
services:
  gitea:
    image: gitea/gitea:latest
    ports:
      - "3000:3000"
    volumes:
      - ./gitea-data:/data
  jenkins:
    image: jenkins/jenkins:lts
    ports:
      - "8080:8080"
    volumes:
      - ./jenkins-data:/var/jenkins_home

4. Ferramentas essenciais de DevOps gratuitas e auto-hospedadas

Versionamento e CI/CD

Gitea é uma alternativa leve ao GitLab, consome menos de 512 MB de RAM e oferece CI/CD integrado (Gitea Actions):

docker run -d --name=gitea \
  -p 3000:3000 -p 22:22 \
  -v ./gitea-data:/data \
  gitea/gitea:latest

Jenkins continua sendo a ferramenta mais flexível para pipelines:

docker run -d --name=jenkins \
  -p 8080:8080 -p 50000:50000 \
  -v ./jenkins-data:/var/jenkins_home \
  jenkins/jenkins:lts

Automação de infraestrutura

Ansible é agente-free e funciona via SSH. Exemplo de playbook simples:

---
- name: Configurar servidor web
  hosts: webservers
  tasks:
    - name: Instalar Nginx
      apt:
        name: nginx
        state: present
    - name: Iniciar serviço
      service:
        name: nginx
        state: started
        enabled: yes

Vagrant cria ambientes reproduzíveis com VirtualBox:

# Vagrantfile
Vagrant.configure("2") do |config|
  config.vm.box = "ubuntu/jammy64"
  config.vm.network "private_network", type: "dhcp"
  config.vm.provision "shell", inline: <<-SHELL
    apt update
    apt install -y docker.io
  SHELL
end

5. Práticas de monitoramento e logging com baixo custo

Prometheus + Grafana formam a dupla mais usada para métricas:

# docker-compose para monitoramento
services:
  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - "9090:9090"
  grafana:
    image: grafana/grafana:latest
    ports:
      - "3001:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin

Para logs centralizados, Loki (Grafana Labs) é mais leve que Elasticsearch:

docker run -d --name=loki \
  -p 3100:3100 \
  grafana/loki:latest

Uptime Kuma monitora serviços e envia alertas por Telegram, Discord ou e-mail:

docker run -d --name=uptime-kuma \
  -p 3002:3001 \
  louislam/uptime-kuma:latest

6. Laboratório de redes e segurança para simular ambientes reais

Crie redes isoladas com bridges no Proxmox ou VirtualBox. Exemplo com VirtualBox:

Configuração de rede no VirtualBox:
- Adaptador 1: NAT (acesso à internet)
- Adaptador 2: Rede Interna (comunicação entre VMs)
- Adaptador 3: Host-Only (acesso do host às VMs)

Simule firewalls com pfSense ou OPNsense em VM:

# Download da ISO do pfSense
wget https://frafiles.netgate.com/mirror/downloads/pfSense-CE-2.7.2-RELEASE-amd64.iso.gz
# Crie VM com 2 placas de rede: WAN (NAT) e LAN (Rede Interna)

Para segurança de containers, use Trivy para escanear vulnerabilidades:

docker run --rm \
  -v /var/run/docker.sock:/var/run/docker.sock \
  aquasec/trivy image nginx:latest

Lynis audita a segurança do sistema host:

sudo apt install lynis -y
sudo lynis audit system

7. Documentação, versionamento de configurações e dicas de manutenção

Mantenha todas as configurações em um repositório Git. Estrutura sugerida:

home-lab/
├── docker-compose/
│   ├── monitoring.yml
│   ├── ci-cd.yml
│   └── gitea.yml
├── ansible/
│   ├── playbooks/
│   └── inventory.ini
├── vagrant/
│   ├── Vagrantfile
│   └── provision.sh
├── dotfiles/
│   ├── .bashrc
│   └── .vimrc
└── docs/
    ├── setup.md
    ├── troubleshooting.md
    └── architecture.md

Documente cada serviço em Markdown. Use Docusaurus ou Wiki.js para criar uma wiki local:

docker run -d --name=wiki \
  -p 4000:3000 \
  -v ./wiki-data:/data \
  requarks/wiki:latest

Estratégias de backup essenciais:

# Script simples de snapshot com rsync
#!/bin/bash
BACKUP_DIR="/backup/$(date +%Y-%m-%d)"
mkdir -p "$BACKUP_DIR"
rsync -av --exclude='*.log' /home/lab/docker-data/ "$BACKUP_DIR"
# Compactar e enviar para nuvem (opcional)
tar -czf "$BACKUP_DIR.tar.gz" "$BACKUP_DIR"

Use snapshots do Proxmox ou VirtualBox antes de mudanças arriscadas. Mantenha um container com cron para backups automáticos.

Com este roteiro, você monta um home lab funcional, gratuito e escalável. Comece pequeno, adicione ferramentas conforme sua evolução e documente cada passo. O aprendizado prático em DevOps não exige grandes investimentos — exige planejamento e curiosidade.

Referências