Estou me mudando para uma nova casa e um dos meus desejos é ter o máximo de tecnologias que puder para soluções de datacenter como um servidor, um servidor de arquivos (NAS) e etc.
Esse post traz o primeiro passo que sempre quis fazer: bloquear anúncios em todos os dispotivos conectados na rede de casa! Sempre usei extensões no navegador para isso, mas não se estendia para as TVs smart e telefones.
O PiHole foi a primeira solução que conheci, mas logo fui apresentado a outras como o Blocky, que foi minha escolha.
É possível rodar o Blocky usando docker, mas de qualquer forma requer um computador ligado 24/7. Para isso, eu vou usar um OrangePi Zero 3, um "computadorzinho" pequeno o suficiente para caber no espaço que tenho no quadro de internet na parede.

Escolhendo uma imagem de sistema

Para configurar o dispositivo, é necessário mais do que simplesmente instalar o Blocky. O processo começa baixando uma imagem para ser escrita diretamente no cartão MicroSD que será plugado no OrangePI.
O website oficial do OrangePI disponibiliza um link para uma imagem Armbian customizada que vem com algumas facilidades, mas para minha configuração baixei a opção Debian 12 (Bookwork) - Minimal / IoT diretamente do website do Armbian.
Também é prudente validar a integridade da imagem baixada com o SHA1 fornecido no website. Para fazer isso, basta baixar ambos arquivos e rodar o comando abaixo, esperando por um OK:

shasum -a 256 -c Armbian_community_25.2.0-trunk.124_Orangepizero3_bookworm_current_6.6.62_minimal.img.xz.sha

Escrevendo no cartão SD

Na documentação do Armbian há um guia para a preparação do cartão SD aqui. É recomendado o uso do Etcher para escrever a imagem no cartão e pode ser encontrado aqui.
Tendo baixado o software, sua interface é bem simples de ser usada: prmeiro selecionar a imagem do Armbian que está em seu disco e então escolher o caminho do cartão SD, que você deve ter plugado em seu computador. Com isso, clique em "Flash" para escrever o sistema operacional no cartão.
Após finalizado, não remova o cartão SD, dado que nos próximos passos alguns arquivos serão modificados.

Configurando a Imagem

Enquanto o cartão SD ainda está plugado no computador é hora de fazer a pré configuração. Após tendo isso feito, durante a primeira inicialização do dispositivo com o cartão SD, o sistema irá assumir algumas configurações padrão em vez de esperar que você faça isso interativamente, como por exemplo configurar as credenciais de WiFi, IP estático e credenciais de acesso.
Pelo terminal, vá até a pasta onde o cartão SD foi montado (o meu ficou em /media/$USER/armbi_root) e então edite o arquivo no caminho ./root/.not_logged_in_yet. Minhas configurações ficaram:

PRESET_NET_CHANGE_DEFAULTS=1
PRESET_NET_ETHERNET_ENABLED=1
PRESET_NET_WIFI_ENABLED=0

PRESET_NET_USE_STATIC=1
PRESET_NET_STATIC_IP="192.168.0.10"
PRESET_NET_STATIC_GATEWAY="192.168.0.1"
PRESET_NET_STATIC_MASK="255.255.255.0"
PRESET_NET_STATIC_DNS="1.1.1.1 1.0.0.1"

SET_LANG_BASED_ON_LOCATION="Y"
PRESET_LOCALE="en_US.UTF-8"
PRESET_TIMEZONE="Etc/UTC"

PRESET_ROOT_PASSWORD="passwd123"

Essas configurações fazem com que o dispositivo conecte-se somente via ethernet (sem WiFi) e que será acessível por um IP estático dentro da rede de meu roteador (192.168.0.0/24).

You're ready to eject the SD Card from your computer and boot the device using it. In next steps, a SSH connection will be made using the assigned addresses and user/password to install Blocky.

Setting up Blocky

With the device online, SSH into it and start installing the needed software: docker, docker-compose and the manifest for having Blocky up.

To get Docker installed, follow the official guide: https://docs.docker.com/engine/install/debian/. The "docker-compose-plugin" is suggested by the doc to be installed and will be needed to setup blocky.
With Docker and Docker Compose installed, it is time to define the compose file and the Blocky's configuration (based in this guide).

Start by creating the file that defines the sources with blocked domains at /home/blocky.config.yaml:

upstreams:
  strategy: strict
  groups:
    default:
      # From https://0xerr0r.github.io/blocky/latest/additional_information/
      - https://anycast.uncensoreddns.org/dns-query
      - https://dns.digitale-gesellschaft.ch/dns-query
      # Open NIC (https://servers.opennic.org/)
      - 168.235.111.72
      - 185.181.61.24
      # Cloudflare
      - 1.1.1.1
      - 1.0.0.1
blocking:
  denylists:
    ads:
      - https://s3.amazonaws.com/lists.disconnect.me/simple_ad.txt
      - https://raw.githubusercontent.com/StevenBlack/hosts/master/hosts
      - https://perflyst.github.io/PiHoleBlocklist/android-tracking.txt
ports:
  dns: 53
  http: 4000

After this, setup the compose file at /home/blocky/docker-compose.yml:

services:
  blocky:
    image: spx01/blocky
    container_name: blocky
    restart: unless-stopped
    hostname: blocky
    ports:
      - "53:53/tcp"
      - "53:53/udp"
      - "4000:4000/tcp"
    environment:
      - TZ=Etc/UTC
    volumes:
      - ./config.yaml:/app/config.yml

Since port 53 is already in use, you must disable systemd-resolved. First, edit the file /etc/systemd/resolved.conf and put the following line:

DNS=1.1.1.1
DNSStubListener=no

Now, reboot the system to take effect!.

And then, after the reboot, start the docker compose up:

docker compose up -d

Configuring the Router

This step varies a lot on each provider's router. But in short, you need to go to your router's page, that is generally on port 80 at 192.168.0.1 (but mine, for example is at 192.168.1.1:18099). The username and password is generally admin (mine is a specific username and password defined by the provider, but they sent it to me).
After logged in, you need to something like Network configuration and change the DNS Server to the static ip assigned to your device.
Blocky has an explanation for it here.