O lixo de uma corporação pode ser o tesouro de um homem, juntei umas peças de descarte e com um pouco de paciência e criatividade, montei um servidorzinho caseiro. De tempos em tempos no meu trabalho são descartadas diversidades de lixo eletrônico, a grande maioria coisas defeituosas ou danificadas e quebradas, mas eventualmente, tem aquela peça que está em boas condições, mas por ser defasada ou não ter nenhuma utilidade a longo prazo, acaba sendo descartada também. Foi nessas que revirando o lixo (literalmente) achei uma coisinha muito da interessante, um mini computador Intel NUC, um tesouro nas mãos certas! Mas será que funciona?

A máquina(zinha)

Ao pesquisar o modelo, fiquei impressionado com as configurações, ele tem um processador Celeron J3455 de quatro núcleos (base de 1,5GHz com turbo de 2,30Ghz) com gráficos integrados, suporta até 8Gb de RAM DDR3L até 1600Mhz, possuí um armazenamento interno de 32Gb eMMC e uma entrada SATA3 adicional, além de um slot para cartão SD externo, três portas USB3 e uma porta USB3.1 (!!), placa de rede Gigabit, placa wireless Wi-Fi AC e Bluetooth 4.2 e saída de vídeo HDMI e VGA. Impressionante! Para os cracudos de hardware, talvez seja algo desprezível, digo de lixo eletrônico mesmo, mas para nós cavaleiros do software livre, pura e simplesmente uma mina de ouro a ser lapidada, meu deux das trevas, isso é tipo ganhar na loteria! Mas só tem valor se tiver como fazer funcionar, e felizmente foi mais simples do que eu imaginava.

Iniciei uma nova calçada por uma fonte compatível, na carcaça do pequenino computador os dizeres “19V 3.4A” alegrou ainda mais meu coração, uma configuração elétrica comum para a maioria dos notebooks, só precisava achar um conector compatível, novamente revirei a montanha de lixo, achei fontes com o conector certo e voltagem insuficiente, e outras com a voltagem certa mas com “plug” diferente, pensei em pegar o plug de um e remendar numa fonte de voltagem certa, mas como não manjo de elétrica fiquei com medo de danificar o computador se fizesse merda, mas felizmente não foi necessário, depois de uma árdua procura achei uma fonte perfeita, usei um multímetro e vi que funcionava, fui testar com o computador e ele ligou! 🥳 Tinha 4Gb de RAM e um SSD de 120Gb com Ruindows 10 instalado, levei meu novo tesouro pra casa pra fazer a manutenção básica dele.

Desmontei-o completamente e limpei a placa-mãe e demais componentes com um pincel pequeno para tirar os anos de poeira acumulada, e finalizei a limpeza com álcool isopropílico que também usei pra remover a pasta térmica que que já havia “empedrado”, depois apliquei uma de melhor qualidade que já tinha em casa. Vi os dois slots de memoria RAM, o que brilhou meu olho, pois muito provavelmente suporta dual channel, lindo, após remontar tudo, instalei mais 4Gb adicionais de RAM que depenei de outro mini computador de descarte, totalizando 8Gb de RAM 1600Mhz. instalei também HD 2.5 mecânico de 1TB que tinha sobrando, e em pouco mais de uma hora já tinha um computador totalmente renovado e funcionando! Isso foi no inicio desse ano mas pra mim parecia 🎄 natal 🎄.

Fiquei algumas semanas com o pequenino parado, estava pesquisando o que fazer, obviamente iria instalar Linux nele, mas qual? Para quem quer fazer um servidorzinho caseiro, já existem opções que automatizam e facilitam imensamente o processo, como o ZimaOS (antigo CasaOS) e o TrueNAS CE, que não curti pois abstraem demais os processos, mas são ótimos para quem não quer se preocupar com o sistema e focar nas aplicações, e também não curti opções mais avançadas como o NixOS e o Proxmox VE pois estou num momento da minha vida que quero evitar camadas de complexidade desnecessárias, como gosto de botar a mão na massa e brincar de configurar computadores, escolhi usar o Debian como sistema base (que já uso para hospedar esse blog), que é uma das mais clássicas e robustas distribuições Linux, e Podman para rodar os containers das aplicações, isso porque ele é super integrado como o ecossistema Linux facilitando rodar as coisas num esquema mais seguro mais intuitivamente (normalmente usam docker para isso mas preferi testar essa solução diferente, spoiler: adorei hehehe).
Então passei os meses seguintes brincando com o computadorzinho e fui descobrindo o que mais me interessava nesse rolê, defini um pequeno roteiro multiuso que deve servir tanto para quem quer saber como fazer a administração básica de um servidor Linux (na unha) e como uma documentação para o eu do futuro consultar facilmente. Meu objetivo aqui será o seguinte:

1. Instalar e configurar o sistema operacional do computador (Debian);
2. Executar as aplicações em um ambiente isolado usando o Podman;
3. Criar uma pasta de rede que poderá ser utilizada por outros computadores aqui em casa, onde arquivos possam ser copiados para essas aplicações facilmente;
4. Centralizar o download de torrents de modo que eu não precise usar meu computador principal pra isso, permitindo que eu semeie torrents por mais tempo gastando muito menos energia elétrica (a comunidade mundial de piratas agradece!).
5. Ouvir e baixar minhas músicas em dispositivos diferentes usando o Navidrome;
6. Ver filmes e séries que tenho salvo pelo celular ou pela TV usando o Jellyfin;
7. Acessar e transferir meus e-books para meu kindle pelo wifi usando o Calibre Web;
8. Fazer backup das fotos do meu celular usando o Immich;
9. Um servidor DNS local com bloqueador de anúncios;

Para o bem ou para o mal, a parte de segurança do sistema vai ter que ficar para outra postagem, vou fazer o básico do básico aqui, infelizmente praticidade e segurança são antagônicos, não dá pra ter ambos e as coisa se complicam muito rapidamente, como esse será um ambiente caseiro para uso recreativo e sempre faço backups dos meus dados mais preciosos, “não tem problema” deixar as coisas mais abertas por enquanto, isso é um ambiente de aprendizado mesmo, estou estudando o básico de hardening e no futuro devo fazer uma postagem continuando o tema que comecei aqui. Enfim, bora botar a mão na massa.

Sistema Operacional

A instalação do sistema operacional foi o processo mais rápido e fácil, simplesmente fiz um pendrive bootável usando o software Ventoy e baixei e coloquei a imagem iso mínima (netinst) mais recente do Debian nele, a instalação nesse modo é super didática e fácil de entender, considero o melhor e mais acessível método de instalação de um sistema operacional livre que já tive experiência, vou citar aqui apenas as alterações pontuais que fiz, já que existem uma infinidade de tutoriais na internet pra isso.

• Desabilitei o usuário root (isto é, escolhi não definir uma senha de root, o que na instalação o debian significa que o usuário será desabilitado) e criei apenas o meu usuário (que terá permissão sudo por padrão).
• Não instalei nenhum ambiente de área de trabalho, apesar de ser plenamente possível ter um, perder 1Gb de RAM pra algo que praticamente não vou usar simplesmente não vale a pena, mas é uma boa para quem está aprendendo.
• Habilitei o serviço SSH na instalação, para não precisar ficar interagindo fisicamente com o servidor sem necessidade (inclusive instalei o sistema via SSH).
• Instalei o sistema no armazenamento eMMC, 32Gb são mais que suficientes para minha brincadeira, e deixei o HD para armazenamento dos arquivos.c
• Deixei um IP reservado para o computadorzinho no meu roteador para ele sempre pegar o mesmo endereço IP, inclusive faço isso com todos os dispositivos de rede fixos aqui em casa, a maioria dos roteadores atualmente é capaz de fazer isso.

Com o sistema instalado, é hora de fazer algumas configurações básicas nele, primeiro criei uma chave SSH para poder acessar a máquina sem precisar inserir a senha do usuário, na minha máquina principal, executei o seguinte comando:

ssh-keygen -C "intel-nuc" -f ~/.ssh/meu_servidor -t ed25519

A opção -C adiciona um comentário para a chave, o que facilita se tu usa muitas delas, a opção -f serve para selecionar o nome e local do arquivo, e a opção -t é pra selecionar o algoritmo do par de chaves, ed25519 é a opção padrão atualmente nas versões mais recentes do openSSH, mas em versões mais antigas o padrão é o RSA que atualmente é considerado inseguro e mais lento. Ao criar as chaves tu pode criar uma senha pra parte privada, o que é sempre uma boa.
Antes de realizar a primeira conexão, vamos copiar a parte pública da chave para o servidor:

ssh-copy-id -i .ssh/meu_servidor.pub bruno@192.168.100.200

Por fim, criei um apelido no meu arquivo de configuração do openSSH na minha máquina principal pra me conectar ao servidor mais rapidamente, normalmente localizado em sua pasta home ~/.ssh/config :

Host homelab # apelido da máquina
  User bruno # seu usuário
  Hostname 192.168.100.200 # endereço ip da máquina
  IdentityFile ~/.ssh/meu_servidor # sua chave ssh
  IdentitiesOnly yes # para se conectar usando apenas a chave
  PreferredAuthentications publickey
  AddKeysToAgent yes # facilita conexões futuras 

Desde modo, basta eu digitar “ssh homelab” que automaticamente vou entrar com o usuário correto usando o endereço certo com a chave correta, muito mais pratico! Com o acesso remoto funcionando, podemos testemunhar uma das maravilhas da imagem do Debian, ao menos nesse sistema, um consumo de memória de apenas pouco mais de 400Mb dos 8Gb disponíveis!

A primeira coisa que vamos fazer é mudar algumas configurações do openSSH no servidor pra não deixar ele muito aberto, vamos abrir o arquivo usando o nano sudo nano /etc/ssh/sshd_config, e localizar e alterar as seguntes configurações:

PermitRootLogin no
PubKeyAuthentication yes
PasswordAuthentication no
PermitEmptyPasswords no

Salve o arquivo e reinicie o serviço openSSH, normalmente as conexões já abertas não caem, mas por via das dúvidas, abra uma nova aba/janela de terminal e tente se conectar novamente pra garantir que deu tudo certo.

sudo systemctl restart sshd

Agora vamos instalar as aplicações que vamos usar, o git é para baixar repositórios da internet, bat instala uma ferramenta chamada batcat que é uma versão visualmente mais agradável do cat, fastfetch é uma besteirinha que gosto de ver quando me logo no servidor, zsh é a shell que gosto de usar, podman para gerenciar os containers, neovim para editar os arquivos (o nano resolve, mas prefiro o neovim), eza é uma versão visualmente mais agradável do ls, unzip para descomprimir arquivos .zip, rsync para copiar arquivos e pastas entre computadores, curl para acessar páginas da web e o samba para gerenciar o compartilhamento de arquivos na rede:

sudo apt update
sudo apt upgrade
sudo apt install git bat fastfetch zsh podman neovim eza unzip rsync curl samba

Gosto de instalar o oh-my-posh e o oh-my-zsh e alguns plug-ins pra customizar a prompt da minha shell (costumo instalar em /usr/bin, assim não preciso atualizar o $PATH), e depois incluir o fastfetch no meu arquivo .zshrc pra me mostrar rapidamente diversas informações do computador ao se logar na máquina. Também baixo ao menos uma fonte NerdFont pra poder ter aqueles ícones legais no terminal (descobri depois que o próprio oh-my-posh tem um utilitário para instalar uma nerdfont, sem precisar fazer tudo manualmente como costumo fazer, para mais informações veja a documentação).

wget https://github.com/ryanoasis/nerd-fonts/releases/download/v3.5.1/CascadiaCode.zip
sudo mkdir /usr/share/fonts
unzip CascadiaCode.zip -d /usr/share/fonts -x LICENSE README.md

A partir dai, copio as configurações do zsh e o tema do oh-my-posh da minha máquina principal para o servidor, dá encontrar uns temas pré-prontos bem legals aqui.

rsync -avr .zshrc .zsh/1_shell.omp.json homelab:~/ --progress

Voltando ao servidor, atualizo o arquivo .zshrc para colocar alguns alias:

export ZSH="$HOME/.oh-my-zsh"

plugins=(git zsh-autosuggestions zsh-syntax-highlighting fast-syntax-highlighting)

source $ZSH/oh-my-zsh.sh

alias ls="eza --icons=always"
alias cat=batcat

fastfetch

eval "$(oh-my-posh init zsh --config ~/1_shell.omp.json)"

Depois é só trocar a shell padrão para o ZSH e ver se tudo está funcionando (deslogar e logar novamente).

chsh -s $(which zsh)
exit
ssh homelab

E assim ficou minha prompt levemente customizada, quem estiver interessado, aqui está o tema do oh-my-posh que uso, uma versão que modifiquei do tema 1_Shell:

As coisas estão bonitinhas, mas não ressuscitei esse computador pra ficar olhando para uma parede de texto colorida, é hora de configurar o armazenamento dos arquivos, e é essa parte entristece um pouco, pois passei uns meses usando o NFS (Network File System) e até que funcionou legal, até eu precisar me conectar pelo meu celular e não conseguir (ao menos não sem instalar algum aplicativo terceiro), pra quem não sabe, NFS é a solução nativa do Kernel Linux para se conectar com pastas de rede, funciona lindamente em sistemas Linux mas infelizmente o suporte em outros sistemas é muito ruim, inclusive no Android, o que considero um absurdo! Até mesmo usando o KDE Plasma no meu computador principal não foi muito intuitivo conseguir me conectar (tive que fazer pelo terminal), talvez a experiência em outros ambientes de desktop como o Gnome seja diferente, mas no final tive que usar o Samba, essa é a solução mais popular por ser compatível com diversos sistemas operacionais, inclusive para poder acessar diretamente do celular. Mas antes, é necessário montar o HD interno, vamos usar o comando lsblk -o NAME,SIZE,R0,TYPE,MOUNTPOINTS,UUID para identificar o HD, abaixo o resultado deve ser algo mais ou menos assim:

NAME           SIZE RO TYPE MOUNTPOINTS UUID
sda          953,9G  0 disk             
mmcblk0       29,1G  0 disk             
├─mmcblk0p1    976M  0 part /boot/efi   (...)
├─mmcblk0p2   26,7G  0 part /           (...)
└─mmcblk0p3    1,5G  0 part [SWAP]      (...)
mmcblk0boot0     4M  1 disk             
mmcblk0boot1     4M  1 disk 

Podemos ver que o HD foi detectado como sda, mas diferente do armazenamento interno do computador, não tem nenhum ponto de montagem, antes de montar ele, vamos formatar esse HD, sabe-se lá deux para o que eu usei ele anteriormente, melhor formatar e começar do zero. Vamos executar o fdisk para formatar esse HD, é uma ferramenta meio pré-histórica mas não conheço nenhuma outra melhor:

sudo fdisk /dev/sda
g # para criar a tabela de partições
n # para criar uma partição
w # para executar as operações

sudo mkfs.ext4 /dev/sda1

Ao executar o mesmo comando lsblk-o NAME,SIZE,R0,TYPE,MOUNTPOINTS,UUID de anteriormente, podemos ver que agora temos um UUID para a partição, já podemos montar o HD, para isso já vamos nos familiarizar com o systemD usando um arquivo .mount, vamos criar esse arquivo no local abaixo, e tem um pequeno detalhe, o nome do arquivo precisa ser exatamente o caminho do qual queremos montar a partição, substituindo as barras (/) por hífens (-), meio nada a ver sendo que dentro do próprio arquivo vamos colocar o caminho absoluto do ponto de montagem, mas enfim, no meu caso, vou montar a partição na pasta /srv que já vem por padrão no Debian. Vou criar o arquivo: sudo nano /etc/systemd/system/srv.mount e colocar as seguintes informações:

[Unit]
Description=Armazenamento de rede 1TB

[Mount]
What=UUID=# O UUID do seu disco, no meu caso o sda
Where=/srv
Type=ext4
Options=defaults

[Install]
WantedBy=multi-user.target

Com isso, podemos finalmente montar o HD, o primeiro comando faz com que o systemD identifique o novo arquivo, e o segundo configura para a montagem ocorra automaticamente na iniciação do sistema, a flag —now informa para fazer isso imediatamente.

sudo systemctl daemon-reload
sudo systemctl enable --now srv.mount

Agora vamos configurar o samba, que vai permitir que possamos acessar esse HD pela minha rede doméstica, para isso precisamos alterar o arquivo /etc/samba/smb.conf adicionando as informações abaixo no final do arquivo:

[homelab-nuc]
   comment = Armazenamento de rede 1Tb
   read only = no
   path = /srv
   guest ok = no
   create mask = 0775
   directory mask = 0775

Depois vamos configurar uma senha para nosso usuário, isso porque o samba tem seu próprio sistema de senhas, usando o comando sudo smbpasswd -a $USER, após isso, basta reiniciar o serviço do Samba:

sudo systemctl restart smbd

Antes de testar a conexão usando meu celular, vou criar umas pastas onde vou organizar meus arquivos, e já corrigi as permissões de acesso para o meu usuário.

sudo mkdir /srv/{downloads,músicas,filmes,séries,imagens,livros}
sudo chown -R bruno:bruno /srv
chmod -R 775 /srv

Testei a conexão com o gerenciador de arquivos do meu celular (o padrão da samsung) e consegui me conectar a pasta de rede, sucesso! Agora é hora de configurar os containers.

Containers

Essa foi a parte mais divertida do projeto, quando se fala em containers, é comum pensar que Docker é a única solução disponível, felizmente isso está longe de ser verdade, apesar uns 90% de todos os tutoriais na internet são pensando para Docker, Podman é uma das alternativas disponíveis, isso porque geralmente containers são padronizados (o padrão OCI - Open Container Initiative), o que permite reproduzir usando ferramentas diversas, não vou me alongar no porque escolhi essa ao invés da outra, para além de achar essa solução mais divertida e interessante, recentemente encontrei um comparativo bem completo entre elas, vale a pena dar uma lida para quem estiver interessado.
O que mais gostei aqui foi poder descrever meus containers usando arquivos de configuração, bem parecido com aquele arquivo .mount que fiz acima, o que aqui são chamados de Quadlets, tudo pode ser um arquivo e isso faz com que tudo seja autoexplicativo. Por ser melhor integrado ao Linux, o Podman usa o systemD para gerenciar os containers e utiliza recursos nativos do Kernel, o que facilita, entre outras coisas, rodar os containers como usuário comum, o que até dá pra fazer no docker, mas por padrão (e a maioria das imagens espera isso) o serviço do docker roda como root e reduz o privilégio do container conforme necessário, o que não acontece no podman, pois ele já inicia o processo com privilégios mais limitados de usuário comum.
Não vou me alongar nas questões técnicas aqui, não faltam artigos muito melhores do que eu poderia escrever na internet, mas posso dizer que iniciei essa jornada usando os aplicativos de forma “nativa”, instalando a partir do próprio Debian ao invés de usar containers e tive a clássica decepção de usar uma versão muito desatualiza dos aplicativos, como usuário de Arch Linux, isso me doeu um pouco. Enfim, antes de baixarmos as imagens e criarmos os containers, vamos configurar duas coisinhas pra facilitar nossa vida. Primeiramente, vamos permitir que o nosso usuário “persista” quando não estamos logados, isso acontece pois todos os processos iniciados por um usuário comum (nós!) são encerrados quando deslogamos do sistema, para permitir que esses processos (nossos containers) possam continuar sendo executados após deslogarmos ou mesmo iniciar automaticamente sem precisar interagir, vamos executar o seguinte comando:

loginctl enable-linger $USER	

Agora, vamos facilitar a pesquisa pelo terminal por novas imagens, isso porque quando não colocamos o endereço completo da imagem que queremos baixar, o podman não vai saber onde procurar ela, o Docker por exemplo sempre procura primeiro no Docker Hub antes de apresentar qualquer erro, isso não acontece aqui, mas felizmente é bem fácil resolver isso, vamos listar os domínios de registro de imagens no arquivo (provavelmente vai precisar criar o caminho) ~/.config/containers/registries.conf da seguinte forma:

mkdir -p ~/.config/containers/systemd
nano ~/.config/containers/registries.conf
# conteúdo do arquivo registries.conf
unqualified-search-registries = ["docker.io", "quay.io", "ghcr.io", "lscr.io"]

Assim sempre que quiser baixar uma imagem, caso não forneça o endereço completo dela, o podman vai perguntar onde quer procurar por ela, isso não é exatamente necessário, principalmente pois vou sempre colocar os endereços completos das imagens que estou utilizando aqui, para o bem ou para o mal, uma mesma aplicação pode ser feita de diversas formas, algumas mais simples e básicas e outras com mais opções e customizadas, como é o caso das imagens do Linux Server, no qual vou utilizar algumas aqui, inclusive é bom ficar de olho onde tu baixar suas imagens, pois é super possível alguém criar uma imagem maliciosa usando o nome de aplicações populares em repositórios por ai, é bom ficar ligado.
Por fim, vamos criar uma rede no qual os containers possam se conectar, isso também não é exatamente necessário, pois o podman cria uma rede padrão caso nenhuma exista, o problema (que acho meio bizarro se me perguntasse) é que essa rede padrão vem com o DNS interno desligado, o que pode dificultar nossa vida no futuro caso queiramos, por exemplo, que um container possa “achar” outro na mesma rede, por isso gosto de criar uma rede pessoal para usar nos meus containers, pois ao criar uma nova rede, ela já vem com o DNS ativado por padrão (a não ser que você explicitamente desative). Poderíamos fazer tudo pelo terminal, mas a beleza de usar os arquivos Quadlets é que posso definir todas as minhas configurações em arquivos independentes, o que facilita o backup e reprodução das minhas configurações em sistemas diferentes, vamos criar um arquivo para definir nossa rede.

nano ~/.config/containers/systemd/homelab.network
# conteúdo do arquivo homelab.network
[Network]
NetworkName=homelab
DisableDNS=false
Subnet=10.89.0.0/24
Gateway=10.89.0.0

Absolutamente nenhuma das opções acima é necessária, a mera existência do arquivo homelab.network mesmo vazio faz com que o podman crie essa rede, desde que ela seja citada como dependência em algum container, mas como será de praxe nessa postagem tutorial, gosto de deixar as coisas o mais explicitas possível, assim meu eu do futuro pode ler esse arquivo em algum momento e pensar “bahh já sei exatamente o que isso faz! Obrigado Bruno do passado!!” e eu acho isso o máximo! Chuuuupa docker!! 🖕🏻
Antes com começar a mexer com os containers, gosto de configurar a atualização automática das imagens, se você não quer ter dor de cabeça, talvez seja interessante pular essa parte, atualizar as imagens cegamente pode não ser um boa ideia, particularmente não me importo e prefiro não precisar fazer isso manualmente, mas fique ciente que eventualmente uma atualização de imagem pode adicionar mudanças que “quebram” versões anteriores sem algum tipo de intervenção manual, estou sempre de olho nas novidades e novamente, eu meio que caguei pra isso, mas não posso deixar te registrar o alerta. Para ativar essa função, o podman tem um serviço pra isso:

systemctl --user enable --now podman-auto-update.timer

Technitium DNS Server

Essa é uma das coisas que eu não fazia ideia da diferença que fazia até usar, falo principalmente pela função de bloqueador de anúncios, no qual eu passei um tempo usando o Pihole, mas rapidamente acabei achando simples demais e sem muita opção pra fuçar, se seu objetivo é apenas bloquear anúncios a nível de DNS, ele é mais que suficiente, para alguém como eu que adora fuçar nas coisas e descobrir novas funções, encontrei o Technitium DNS Server que possui as mesmas funções do Pihole e muito mais, aqui é possível inclusive baixar apps (tipo extensões) para extender as funções do aplicativo. Aqui vamos precisar alterar uma limitação do sistema caso queiramos usar sem maiores complicações, acontece que o DNS em texto simples é padronizado para usar a porta 53, mas como vamos executar os containers em modo rootless, por padrão não temos acesso a portas menores que 1024, felizmente mudar isso é bastante simples, poderíamos usar um redirecionar de portas de um firewall como o firewalld ou simplesmente remover essa limitação, vou fazer a segunda opção pois, novamente, não sou o doidinho da segurança da informação aqui, vamos fazer funcionar primeiro, depois vemos isso.
Vamos criar o arquivo sudo nano /etc/sysctl.d/99-sysctl.conf e adicionar esses parametros:

net.ipv4.ip_unprivileged_port_start=53
kernel.unprivileged_userns_clone = 1

Com isso, vamos aplicar as mudanças com o comando sudo sysctl --system. Antes de criarmos o arquivo quadlet para esse container, vamos baixar a imagem que iremos usar:

podman pull docker.io/technitium/dns-server:latest

Agora vamos criar o arquivo .container para nosso servidor dns, diferente do arquivo .mount que criamos anterior, podemos nomeá-lo como quisermos, desde que o arquivo tenha a extensão correta. No meu caso vou usar nano .config/containers/systemd/technitium.container e adicionar as configurações abaixo:

[Unit]
Description=Servidor DNS Technitium
After=network-online.target

[Container]
Image=docker.io/technitium/dns-server:latest
ContainerName=dns-server
HostName=dns-server
AutoUpdate=registry

# Porta da WebUI
PublishPort=5380:5380/tcp
# Portas DNS
PublishPort=53:53/udp
PublishPort=53:53/tcp
# As portas abaixo são opcionais
PublishPort=853:853/udp
PublishPort=853:853/tcp
PublishPort=443:443/tcp
PublishPort=443:443/udp

Environment=DNS_SERVER_NAME=dns-server
Secret=dns-server-password,type=env,target=DNS_SERVER_ADMIN_PASSWORD

Volume=%h/.config/containers/storage/technitium:/etc/dns

Network=homelab.network

[Service]
Restart=always
RestartSec=10
TimeoutStartSec=120

[Install]
WantedBy=default.target

Um breve comentário sobre cada um desses campos, pois nem todos são autoexplicativos:

1. Campo [Unit] gerencia informações sobre o serviço systemD:

   • Description: Uma descrição básico do serviço
   • After: Usado para gerenciar dependências entre serviços e estados do computador, nesse caso queremos que o container inicie apenas após uma conexão com a internet seja estabelecida.

2. Campo [Container] gerencia informações sobre o container:

   • Image: Define o endereço da imagem a ser utilizada, pode ser tanto um endereço web ou um caminho local da máquina.
   • ContainerName: Defini o nome do container, é opcional, gosto de ter nomes específicos fixos.
   • HostName: Define nome da máquina dentro do ambiente do container, também é opcional, novamente gosto de nomes fixos para os meus containers.
   • AutoUpdate: Define como a imagem será atualizada, nesse caso configuramos para verificar pelo endereço web da imagem, é possível verificar localmente também.
   • PublishPort: Define a atribuição de portas entre o host (nosso servidor) e o container, gosto de deixar comentários acima de cada parâmetro desse para saber exatamente para que essa porta é utilizada.
   • Environment: Define variáveis de ambiente dentro do container, muito utilizado para configurar opções especificas de aplicações.
   • Secret: Não é recomendável deixar informações sensíveis expostas em variáveis de ambiente, para isso existe a função secrets do podman, onde é possível guardar e transmitir de forma segura informações confidenciais, para maiores informações sobre como criar e gerenciar segredos basta consultar a documentação. Abaixo um exemplo de como criar um, o primeiro comando cria um secret chamado nome-do-segredo, o hífen no final faz com que qualquer espaço em branco antes e depois da string do comando echo seja removido, o segundo comando apaga o arquivo .bash_history (ou .zsh_history como é o meu caso) para evitar deixar a informação exposta. Saiba que uma vez que tu cria o secret não tem como consultar ele, apenas utilizar.

   echo -n "seu segredo ultra secreto" | podman secret create nome-do-segredo -
   history -c
   

   • Volume: Os arquivos gerados por um container só existem durante a vida útil dele, qualquer informação salva em disco é apagada ao fim da execução, então criamos um volume para indicar um espaço no disco onde o container pode utilizar, isso cria um espaço de informações persistentes, útil por exemplo para salvar customizações da aplicação.
   • Network: Define a rede que será utilizada, opcional, aqui apontamos para o arquivo .network que criamos anteriormente.

3. Campo [Service] define opções do serviço systemD:

   • Restart: Define quando e como o container deve reiniciar em caso de falha.
   • RestartSec: Define o tempo em segundos entre cada tentativa de reinicar o container.
   • TimeoutStartSec: Define o tempo máximo permitido que o container pode levar para iniciar, em segundos, como ativamos a opção de atualizar automaticamente, é importante deixar um tempo extra para que uma nova imagem dê tempo de ser baixada caso uma nova atualização seja detectada.

4. Campo [Install] define quando o container deve iniciar sozinho, nesse caso ele vai iniciar automaticamente mesmo que nenhum usuário se logue na máquina.

Parece tudo certo, vamos executar o comando abaixo para que o systemD detecte o arquivo do container e crie um serviço automaticamente para ele, após executar o comando, pode levar alguns minutos até o container subir pela primeira vez, uma vez que ele estará criando todos os arquivos necessários:

systemctl --user daemon-reload

Para verificar se o container está ativo, podemos executar o comando abaixo:

systemctl --user status technitium

Se tudo der certo, você verá algumas informações sobre o processo do container:

No nosso caso o container já está rodando, ótimo, vamos abrir um navegador e acessar a endereço do container a partir do meu computador, que no meu caso é o 192.168.100.200:5380, e voilá, o serviço está funcionando, vamos entrar com o usuário admin e a senha que definimos no parâmetro Secret do container. A primeira coisa que gosto de fazer é criar um usuário pra mim e deixar esse admin de reserva, basta ir em Administration >> Users e criar seu usuário, mas isso é opcional. Depois vamos em Settings >> Blocking e vou ativar e selecionar uma (ou mais) lista(s) de bloqueio de domínios, gosto de usar a lista abaixo, mas lembrando que é possível encontrar outras pela internet:

Dá pra usar diversas listas, agora, vamos na opção Proxy & Forwarders e em Forwarders podemos selecionar um serviço de DNS para usar, isso porque nosso servidors DNS não possui registros, então precisamos pegar de algum outro lugar, na lista existem as opções mais populares como a Cloudflare que costumo usar, mas também o Google DNS e o Quad9, também é possível colocar outros endereços caso queira alguma outra opção mais obscura, não esqueça de clicar no botão Save Settings para aplicar as alterações.

Por fim, precisamos indicar nossos computadores para usar nosso servidor DNS, inicialmente eu seto manualmente no meu computador e se fico satisfeito com o resultado, altero o DNS no roteador para aplicar a toda a rede, mas como não gosto de deixar esse servidor ligado 24 por 7, até porque se não tem ninguém em casa e não tenho (ao menos atualmente) a vontade de acessar ele remotamente, não tem porque ele ficar ligado gastando energia atoa, por isso deixo o Cloudflare como segunda opção para quando o servidor estiver desligado dê pra acessar a internet normalmente. E é isso, agora temos um servidor DNS com bloqueador de anúncios. Uma última dica que dou é ao menos inicialmente ficar de olho na parte inferior do Dashboard do servidor, onde mostrar os domínios que foram liberados e os bloqueados, em todos os meus navegadores uso a extensão do Tor Snowflake para ajudar pessoas a burlar bloqueio de internet e os domínios deles sempre são bloqueados, se tiver algum site que não está carregando, dá pra liberar facilmente pela própria dashboard.

Nos vemos em breve

Ainda tem diversos serviços que rodo nesse computadorzinho, mas percebi que se eu for esperar completar essa postagem para de fato postar aqui no blog, vou levar pelo menos mais uns seis meses, isso que eu queria ter publicado isso lá em Abril! Portanto vou deixar essa postagem em construção até eu esteja com mais textos sobre os demais serviços que uso.