Estou me mudando para uma nova casa e um das minhas ideias é ter o máximo de tecnologias que puder para hospedar aplicações em casa, 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 Etcher, sua interface é bem simples de ser usada: prmeiro selecionar a imagem do Armbian que está no computador 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. Esta configuração serve para que, durante a primeira inicialização do dispositivo com o cartão SD, o sistema assuma 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).

Configurando o Blocky

Com o dispositivo online, conecte através de SSH para instalar os softwares necessários: docker, docker compose e o yml para definição do serviço do Blocky.

Para instalar o Docker, siga o guia oficial: https://docs.docker.com/engine/install/debian/. A instalação do "docker-compose-plugin" é sugerido na documentação e é necessário para subir o projeto.
Com o Docker e Docker Compose instalados, é hora de definir o arquivo do Compose e escrever a configuração necessária para o Blocky, baseado neste guia.

Comece criando o arquivo que define as bases de domínios a bloquear. Esse arquivo deve ficar em /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

Com isso feito, escreva o arquivo de configuração do Compose em /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

Como a porta 53 já estará em uso por padrão, você deve desabilitar o systemd-resolved. Primeiro, edite o arquivo /etc/systemd/resolved.conf e coloque as seguintes linhas:

DNS=1.1.1.1
DNSStubListener=no

Agora, reinicie para ter efeito.

Depois da reinicialização, inicialize o Blocky pelo docker compose:

docker compose up -d

Configurando o Roteador

Os passos a seguir variam de roteador para roteador. Mas em resumo, você precisa ir até a página de seu roteador, geralmente na porta 80 do IP 192.168.0.1 (mas o meu, por exemplo, fica acessível em 192.168.1.1:18099). O usuário e senha geralmente são admin (o meu tinha um usuário e senha específico definidos pelo provedor, mas me forneceram assim que pedi).
Após tendo feito o login, você precisa ir até uma seção de rede (Network) e alterar o DNS Server para o IP estático que direcionou para seu dispositivo (em meu exemplo, 192.168.1.10).
O Blocky possui um guia para isso aqui.