Os artigos mais lidos de 2024

Home

Acessos de robôs nos logs web

Details
Written by: Helio Loureiro
Category: Perl
Hits: 673

Esses dias eu vi um post no Mastodon sobre bloquear robôs que acessam o servidor web.

Perguntei pro autor do post como foi que ele conseguiu isso, mas fui solenemente ignorado. Coisas da Internet.

Então resolvi dar uma olhada nos logs do servidor, esse que hospeda esse mesmo site. E fiz um programa em perl pra isso. Pra matar as saudades. E tirar a ferrugem.

E esse foi o programa: 

  
#! /usr/bin/env perl
use IO::Zlib;

my $LOGDIR = "/var/log/apache2";

opendir(DIR, $LOGDIR) or die "Impossible to read from directory: $!\n";

%ip_addrs;
%bot_agent;

@gzip_files;

foreach my $filename (readdir DIR) {
        next if $filename !~ /access/;
        # skip gz right now
        if ($filename =~ /\.gz/) {
                push(@gzip_files, ($LOGDIR."/".$filename));
                next;
        }

        print($LOGDIR."/".$filename."\n");
        open(FD, $LOGDIR."/".$filename) or die "Impossible to read file: $!\n";
        foreach my $line () {
                next if $line !~ /bot/;
                parse_log_line($line);
        }
}


print("result:\n");


for my $filename (@gzip_files) {
        print("$filename\n");
        my $fh = new IO::Zlib;
        $fh->open($filename, "rb") or die "impossible to read gzip file: $!\n";
        while ( my $line = <$fh>) {
                next if $line !~ /bot/;
                parse_log_line($line);
        }
}

foreach $bot (sort {$bot_agent{$b}<=>$bot_agent{$a} } keys %bot_agent) {
    print("$bot => $bot_agent{$bot}\n");
}

sub parse_log_line() {
        my $line = $_[0];
        our %ip_addrs;
        our %bot_agent;

        @params = split(/ /, $line);
        my $ip = $params[0];
        $ip_addrs{$ip}++;
        $line =~ s/.*]//;
        $line =~ s/\"$//;
        $line =~s/.*\"//;
        chomp($line);
        if ($line =~ m/bot/) {
                $bot_agent{$line}++;
        }
}

E o resultado em formato de tabela:

User-Agent do robô Quantidade de acessos
Mozilla/5.0 (compatible; MJ12bot/v1.4.8; http://mj12bot.com/) 30130
Mozilla/5.0 (compatible; SemrushBot/7~bl; +http://www.semrush.com/bot.html) 22203
Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; ClaudeBot/1.0; This email address is being protected from spambots. You need JavaScript enabled to view it.) 16981
Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; bingbot/2.0; +http://www.bing.com/bingbot.htm) Chrome/116.0.1938.76 Safari/537.36 15979
Mozilla/5.0 (compatible; AhrefsBot/7.0; +http://ahrefs.com/robot/) 12112
Mozilla/5.0 (Linux; Android 7.0;) AppleWebKit/537.36 (KHTML, like Gecko) Mobile Safari/537.36 (compatible; PetalBot;+https://webmaster.petalsearch.com/site/petalbot) 10744
Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; Amazonbot/0.1; +https://developer.amazon.com/support/amazonbot) Chrome/119.0.6045.214 Safari/537.36 9704
Mozilla/5.0 (compatible; DotBot/1.2; +https://opensiteexplorer.org/dotbot; This email address is being protected from spambots. You need JavaScript enabled to view it.) 7434
Mozilla/5.0 (compatible; AwarioBot/1.0; +https://awario.com/bots.html) 5042
Mozilla/5.0 (compatible; DataForSeoBot/1.0; +https://dataforseo.com/dataforseo-bot) 3104
Linguee Bot (http://www.linguee.com/bot; This email address is being protected from spambots. You need JavaScript enabled to view it.) 1957
Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15 (Applebot/0.1; +http://www.apple.com/go/applebot) 1450
Mozilla/5.0 (compatible; archive.org_bot +http://archive.org/details/archive.org_bot) Zeno/5741de8 warc/v0.8.85 751
Mozilla/5.0 (compatible; SemrushBot-BA; +http://www.semrush.com/bot.html) 651
Mozilla/5.0 (compatible; YandexBot/3.0; +http://yandex.com/bots) 567
Mozilla/5.0 (compatible; MJ12bot/v2.0.2; http://mj12bot.com/) 538
Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.183 Mobile Safari/537.36 (compatible; Googlebot/2.1; +http://www.google.com/bot.html) 531
Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html) 411
Blogtrottr/2.1 (+https://blogtrottr.com/robot) 340
Googlebot-Image/1.0 315
Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; bingbot/2.0; +http://www.bing.com/bingbot.htm) Chrome/100.0.4896.127 Safari/537.36 300
Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; GPTBot/1.2; +https://openai.com/gptbot) 261
Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36; compatible; OAI-SearchBot/1.0; +https://openai.com/searchbot 240
Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.7151.119 Mobile Safari/537.36 (compatible; Googlebot/2.1; +http://www.google.com/bot.html) 207
Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; bingbot/2.0; +http://www.bing.com/bingbot.htm) Chrome/136.0.0.0 Safari/537.36 191
ZoominfoBot (zoominfobot at zoominfo dot com) 164
Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; ChatGPT-User/1.0; +https://openai.com/bot 150
Mozilla/5.0 (compatible; SeznamBot/4.0; +https://o-seznam.cz/napoveda/vyhledavani/en/seznambot-crawler/) 124
Mozilla/5.0 (compatible; MojeekBot/0.11; +https://www.mojeek.com/bot.html) 107
Mozilla/5.0 (compatible; archive.org_bot +http://archive.org/details/archive.org_bot) Zeno/a7797cb warc/v0.8.78 89
DuckDuckBot/1.1; (+http://duckduckgo.com/duckduckbot.html) 82
Mozilla/5.0 (compatible;PetalBot;+https://webmaster.petalsearch.com/site/petalbot) 80
Mozilla/5.0 (compatible; YandexImages/3.0; +http://yandex.com/bots) 70
Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; PerplexityBot/1.0; +https://perplexity.ai/perplexitybot) 62
Mozilla/5.0 (compatible; YaK/1.0; http://linkfluence.com/; This email address is being protected from spambots. You need JavaScript enabled to view it.) 61
Mozilla/5.0 (compatible; coccocbot-image/1.0; +http://help.coccoc.com/searchengine) 56
Mozilla/5.0 (compatible; wpbot/1.3; +https://forms.gle/ajBaxygz9jSR8p8G9) 41
Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; Googlebot/2.1; +http://www.google.com/bot.html) Chrome/137.0.7151.119 Safari/537.36 37
Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.168 Mobile Safari/537.36 (compatible; Googlebot/2.1; +http://www.google.com/bot.html) 29
Twitterbot/1.0 29
AdsBot-Google (+http://www.google.com/adsbot.html) 22
Mozilla/5.0 (compatible; intelx.io_bot +https://intelx.io) 21
BufferLinkPreviewBot/1.0 (+https://scraper.buffer.com/about/bots/link-preview-bot) 19
Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.84 Mobile Safari/537.36 (compatible; Googlebot/2.1; +http://www.google.com/bot.html) 14
Mozilla/5.0 (compatible; Thinkbot/0.5.8; +In_the_test_phase,_if_the_Thinkbot_brings_you_trouble,_please_block_its_IP_address._Thank_you.) 13
Mozilla/5.0 (compatible; MJ12bot/v2.0.4; http://mj12bot.com/) 13
Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.183 Mobile Safari/537.36 (compatible; AdsBot-Google-Mobile; +http://www.google.com/mobile/adsbot.html) 9
Mozilla/4.0 (compatible; fluid/0.0; +http://www.leak.info/bot.html) 8
Mozilla/5.0 (Windows NT 10.0; Win64; x64; trendictionbot0.5.0; trendiction search; http://www.trendiction.de/bot; please let us know of any problems; web at trendiction.com) Gecko/20100101 Firefox/125.0 7
Googlebot/2.1 (+http://www.google.com/bot.html) 5
Mozilla/5.0 (compatible; SurdotlyBot/1.0; +http://sur.ly/bot.html) 5
Mozilla/5.0 (compatible; Website-info.net-Robot; https://website-info.net/robot) 4
Mozilla/5.0 (compatible; coccocbot-web/1.0; +http://help.coccoc.com/searchengine) 4
Pandalytics/2.0 (https://domainsbot.com/pandalytics/) 4
Mozilla/5.0 (compatible; IbouBot/1.0; This email address is being protected from spambots. You need JavaScript enabled to view it.; +https://ibou.io/iboubot.html) 4
DomainStatsBot/1.0 (https://domainstats.com/pages/our-bot) 4
Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/W.X.Y.Z Mobile Safari/537.36 (compatible; Googlebot/2.1; +http://www.google.com/bot.html) 3
Mozilla/5.0 (compatible; SeekportBot; +https://bot.seekport.com) 3
serpstatbot/2.1 (advanced backlink tracking bot; https://serpstatbot.com/; This email address is being protected from spambots. You need JavaScript enabled to view it.) 3
Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_1) AppleWebKit/601.2.4 (KHTML, like Gecko) Version/9.0.1 Safari/601.2.4 facebookexternalhit/1.1 Facebot Twitterbot/1.0 3
yacybot (-global; amd64 Linux 5.15.161; java 11.0.26-internal; America/en) http://yacy.net/bot.html 2
Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; Googlebot/2.1; +http://www.google.com/bot.html) Chrome/120.0.6099.199 Safari/537.36 2
Mozilla/5.0 (compatible; Qwantbot/1.0_4396629; +https://help.qwant.com/bot/) 2
DomCopBot (https://www.domcop.com/bot) 2
Mozilla/5.0 (compatible; YandexFavicons/1.0; +http://yandex.com/bots) 2
yacybot (/global; amd64 Linux 5.15.0-140-generic; java 11.0.27; America/en) http://yacy.net/bot.html 2
Synapse (bot; +https://github.com/matrix-org/synapse) 2
Mozilla/5.0 (compatible; archive.org_bot; Wayback Machine Live Record; +http://archive.org/details/archive.org_bot) 1
Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Mobile Safari/537.36 (compatible; Googlebot/2.1; +http://www.google.com/bot.html) 1
Mozilla/5.0 (compatible; Qwantbot/1.0; +https://help.qwant.com/bot/) 1
Facebot 1
Mozilla/5.0 (compatible; GetHPinfo.com-Bot/0.1; +http://www.gethpinfo.com/bot/ 1
Slack-ImgProxy (+https://api.slack.com/robots) 1
Googlebot-Video/1.0 1
yacybot (/global; amd64 Linux 6.12.38+deb13-amd64; java 21.0.8; Europe/fr) http://yacy.net/bot.html 1
Mozilla/5.0 (iPhone; CPU iPhone OS 6_0 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/6.0 Mobile/10A5376e Safari/8536.25 (compatible; SMTBot/1.0; +http://www.similartech.com/smtbot) 1
Mastodon/4.5.0-alpha.1+chuckya (http.rb/5.3.1; +https://lab.wheelsbot.dev/) 1

O resultado é texto. Eu só formatei pra ficar mais fácil de visualizar aqui (usando "sd" pra isso). E está hardcoded pra buscar os logs do apache2 em sistemas debian alike.

Dos resultados, confesso que fiquei surpreso. Realmente bastante tráfego vindo de robôs. E vários que eu nunca ouvi falar.

Sobre bloquear ou não, eu por enquanto não mexi em nada e os robôs continuam acessando tudo. Mesmo porque eu não fiz nada qualitativo, pra saber se estão recebendo 200 (ok) ou alguma outra coisa como 404 (not found - não encontrad).

Mas caso eu decida pelo bloqueio, achei um projeto bem interessante no GitHub que já faz a curadoria de robôs "bons" e "ruins".

Atualizando mapas de DNS no estilo do DynDNS

Details
Written by: Helio Loureiro
Category: Python
Hits: 558

Eu tenho rodado um tipo de sistema que faz DynDNS pra minhas máquinas que estão atrás de um serviço de DHCP como meu desktop que fica aqui em minha mesa, em casa.

O princípio é que essa máquina acessa uma certa URL a cada 5 minutos. Então a cada 5 minutos eu olho pro log do servidor web que roda nessa porta e pego os dados. Pego o IPv4 e o IPv6. Na verdade pego o que vier e vejo se é IPv4 ou IPv6. Depois olho no mapa de DNS se o valor mudou. Se mudou, altero o serial do map e mando um restart no serviço.

A lógica é simples. Mas eu fiz isso uns 15 anos atrás. Pra python2.Alguma-Coisa. Portei pra python3 no melhor estilo #XGH. O resultado? Problemas aqui e ali.

Vamos dar uma olhada no script anterior. 

  
#! /usr/bin/python3 -u
# -*- encoding: utf-8 -*-

"""
DNS updater.  It checks if hostname and IP are updated
on maps.  If not, update accordingly and reload bind.
"""
# grep "\/\?update_dyndns=" /var/log/apache2/dyndns-access.log | sed "s/ HTTP.*//" | awk '{print $1, $NF}'

import re
import time
import os
import subprocess
import sys

LOG = "/var/log/apache2/dyndns-access.log"
DNSCONF = "/etc/bind/master/dyndns.truta.org"
DNSDATE = "/etc/bind/master/db.truta.org"
DNSFILES = [ DNSDATE, "/etc/bind/master/db.linux-br.org" ]

TRANSLATE = {
    "goosfraba" : "helio",
    "raspberrypi-masoso" : "rpi0",
    "raspberrypi1" : "rpi1",
    "raspberrypi2" : "rpi2",
    "raspberrypi3" : "rpi3"
    }

def debug(*msg):
    if "DEBUG" in os.environ:
        print("DEBUG:", *msg)

def get_latest_ips():
    """
    Dictionary in format:
        Domain/node : [ ipv4, ipv6]
    """
    debug("get_latest_ips()")
    NODE_IP = {}
    with open(LOG) as logfile:
        for line in logfile.readlines():
            if not re.search("\/\?update_dyndns=", line):
                continue
            line = re.sub(" HTTP.*", "", line)
            param = line.split()
            ip = param[0]
            nodename = re.sub("\/\?update_dyndns=", "", param[-1])

            if not nodename in NODE_IP:
                NODE_IP[nodename] = [ None, None ]
            # ipv4?
            if re.search("([0-9].*)\.([0-9].*)\.([0-9].*)\.([0-9].*)", ip):
                NODE_IP[nodename][0] = ip
                debug(f"{nodename} (ipv4): {ip}")
            else:
                NODE_IP[nodename][1] = ip
                debug(f"{nodename} (ipv6): {ip}")
    return NODE_IP

def apply_translate(DIC):
    debug("apply_translate()")
    # DIC = {  translatedName : [ipv4, ipv6] }
    debug("apply_translate(): DIC:\n", DIC)
    tempDIC = {}
    for nodename in DIC:
        debug(f"apply_translate(): searching {nodename}")
        if not nodename in TRANSLATE:
            debug(f"{nodename} not in TRANSLATE table")
            continue
        dnsName = TRANSLATE[nodename]
        if dnsName is None:
            debug(f"{nodename} translates to None")
            continue
        nodeValue = DIC[nodename]
        debug(f"apply_translate(): adding {dnsName} as {nodeValue}")
        tempDIC[dnsName] = nodeValue
    debug("apply_translate(): returning tempDIC:\n", tempDIC)
    return tempDIC

def check_for_update(DIC):
    debug("check_for_update()")
    isupdated = False
    buf = ""
    debug("check_for_update(): current DNS entries")
    with open(DNSCONF) as fh:
        for line in fh.readlines():
            if line.startswith(";") or line.startswith("#"):
                buf += line
                continue
            line = line.rstrip()
            param = line.split()
            if len(param) != 3:
                buf += f"{line}\n"
                continue
            subname, subtype, subip = param
            print(f"DNS current entry: {subname}, Type: {subtype}, IP: {subip}")
            if not subname in DIC:
                debug(f"check_for_update(): {subname} is not into the DIC")
                buf += f"{line}\n"
                continue
            ipv4, ipv6 = DIC[subname]
            print(f"Found {subname} for update")
            # ipv4
            if subtype == "A":
                print("Checking IPv4")
                if ipv4 != subip and len(ipv4) > 0:
                    print(f" * Updating {subname} from {subip} to {ipv4}")
                    isupdated = True
                    buf += f"{subname}\t\t\t{subtype}\t{ipv4}\n"
                    continue
            # ipv6
            if subtype == "AAAA":
                print("Checking IPv6")
                if ipv6 != subip and len(ipv6) > 0:
                    print(f" * Updating {subname} from {subip} to {ipv6}")
                    isupdated = True
                    buf += f"{subname}\t\t\t{subtype}\t{ipv6}\n"
                    continue
            buf += f"{line}\n"
        if isupdated:
            print(f"Updating file {DNSCONF}")
            debug("check_for_update(): buf:", buf)
            with open(DNSCONF, 'w') as fh:
                fh.write(buf)
        return isupdated

def get_dns_map_serial(dns_file: str) -> str:
    with open(dns_file) as fh:
        for line in fh.readlines():
            if not re.search(" ; serial", line):
               continue
            timestamp = line.split()[0] 
            return timestamp
    raise Exception(f"Failed to read serial from dns file: {dns_file}") 

def get_serial_date_update(timestamp: str) -> list:
    if len(timestamp) != 10 :
        raise Exception(f"Wrong timestamp size (not 10): {timestamp}") 
    dateformat = timestamp[:8]
    serial = timestamp[8:]
    return (serial)

def update_serial_in_file(old_serial: str, new_serial: str, filename: str) -> None:
    with open(filename) as fh:
        buf = fh.read()
    buf = re.sub(old_serial, new_serial, buf)
    with open(filename, 'w') as fw:
        fw.write(buf)

def update_timestamp(dryrun=False):
    debug("update_timestamp()")
    buf = ""
    today = time.strftime("%Y%m%d", time.localtime())

    timestamp = get_dns_map_serial(DNSDATE)
    (last_update, last_serial) = get_serial_date_update(timestamp)
    print("Timestamp:", timestamp)
    print("Last update:", last_update)
    print("Last serial:", last_serial)
    original_timestamp = ""
    if int(today) > int(last_update):
       timestamp = f"{today}00"
    else:
      serial = int(last_serial) + 1
      if serial < 100:
         timestamp = "%s%02d" % (today, serial)
      else:
         timestamp = "%08d00" % (int(today) + 1)
      print("New timestamp:", timestamp)
    print("Updating file", DNSDATE)
    debug(f"update_timestamp(): timestamp={timestamp}")
    if dryrun is False:
        update_serial_in_file(original_timestamp, timestamp, DNSDATE)
    else:
        print("-= dry-run mode =-")
        print(f"Here file {DNSDATE} would be updated.")
        print("Content:\n", buf)

def bind_restart(dryrun=False):
    #cmd = "systemctl restart named.service"
    ## reload is enough
    cmd = "systemctl reload named.service"
    if dryrun is False:
        subprocess.call(cmd.split())
    else:
        print("-= dry-run mode =-")
        print(f"Here command would be called: {cmd}")

def main():
    now = time.ctime(time.time())
    print(f"Starting: {now}")
    DNS = get_latest_ips()
    DNS = apply_translate(DNS)
    debug(DNS)
    status = check_for_update(DNS)
    if status:
        if len(sys.argv) > 1 and sys.argv[-1] == "--help":
            print(f"Use: {sys.argv[0]}  [--help|--dry-run]")
            sys.exit(0)
        if len(sys.argv) > 1 and sys.argv[-1] == "--dry-run":
            doDryRun = True
        else:
            doDryRun = False
        update_timestamp(dryrun=doDryRun)
        bind_restart(dryrun=doDryRun)

if __name__ == '__main__':
    main()

O código está gigante e uma zona. E estava dando crash. Vamos então olhar por partes. 

  
LOG = "/var/log/apache2/dyndns-access.log"
DNSCONF = "/etc/bind/master/dyndns.truta.org"
DNSDATE = ""
DNSFILES = [ DNSDATE, "/etc/bind/master/db.linux-br.org" ]

LOG é onde eu tenho de ler pra buscar o padrão de acesso. DNSCONF é onde ficam as definições de "IP TIPO NOME" como "1.2.3.4 A helio" pro caso de IPv4. DNSDATE é onde ficavam as atualizações pro domínio truta.org. Eu percebi que dava pra fazer a mesma coisa com outros domínios, então depois eu inseri junto o DNSFILES pra ter também o linux-br.org. No final esses aquivos só precisam ser abertos pra alterar o serial.

O mapa de dns, pra entender o que é, é esse aqui pro truta.org: 

  
❯ cat /etc/bind/master/db.truta.org
$TTL 180        ; # three minute
@               IN SOA  ns1.truta.org. helio.loureiro.eng.br. (
                                2025080800 ; serial
                                43200      ; refresh (12 hours)
                                3600       ; retry (1 hour)
                                604800     ; expire (1 week)
                                86400      ; minimum (1 day)
                                )
@                       NS      ns1.truta.org.
@                       NS      ns2.afraid.org.
@                       NS      ns1.first-ns.de.
@                       NS      robotns2.second-ns.de.
@                       NS      robotns3.second-ns.com.
@                       A       95.216.213.181
@                       MX      5 mail.truta.org.
@                       AAAA    2a01:4f9:c012:f3c4::1
@                       TXT     "v=spf1 a mx ip4:95.216.213.181 ip6:2a01:4f9:c012:f3c4::1 include:_spf.google.com -all"
mail._domainkey         IN      TXT     "v=DKIM1; k=rsa; t=y; p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCpp/HlB1QAHjp6jHGCj9kfcZSjY3ipbGuU/enVjEeptlNgw2qTxRRJ6puPiW5DWCOaPEg2nC//wRazFgMuLZ3C89vF2TT57upngmNuCcLtbwNxo6G1JFo5GD92UbQgstYC+cjfrRlw56XfwzWVtojR4ZCB8PCQCguwhwunwRhJEwIDAQAB" ; ----- DKIM key mail for truta.org
; As e AAAAs

; CNAMES
www                     AAAA    2a01:4f9:c012:f3c4::1
www                     A       95.216.213.181
ns1                     A       95.216.213.181
                        AAAA    2a01:4f9:c012:f3c4::1
mail                    A       95.216.213.181
                        AAAA    2a01:4f9:c012:f3c4::1

; DYNAMIC TRUTAS
$INCLUDE "/etc/bind/master/dyndns.truta.org";

A linha que precisa ser alterada é a que tem 2025080800 ; serial. A parte que faz a mágica de ler os novos endereços IPs é $INCLUDE "/etc/bind/master/dyndns.truta.org";. E se não está familiarizado com mapas de dns, o que tem depois do ";" é ignorado. Então o bind lê somente o 2025080800. O ; serial é um comentário pra humanos entenderem o que é aquilo.

O serial é um número inteiro. Você pode usar qualquer número. Só precisa incrementar quando faz alguma alteração no mapa pra poder notificar que houve mudança pro seus secundários. A boa prática é usar YYYYMMDDXX onde:

  • YYYY: ano com 4 dígitos
  • MM: mês com 2 dígitos
  • DD: dia com 2 dígitos
  • XX: um número inteiro com 2 dígitos

Então se o mapa é atualizado no mesmo dia, você incrementa o XX. Claro que isso te limita à 100 alterações por dia, de 0 a 99. Mas não é algo como ficar atualizando tanto o mapa. A menos que você seja um provedor de cloud. Daí as coisas funcionam de jeito beeeeem diferente. Mas vamos ficar no feijão com arroz.

Vamos voltar ao script. Como está escrito com funções, fica mais fácil de olhar pra cada uma independentemente. Eu vou colocar fora de ordem pra ficar mais claro o que faz o quê. Ou o que deveria fazer o quê. 

  
def debug(*msg):
    if "DEBUG" in os.environ:
        print("DEBUG:", *msg)

Isso é claramente uma gambiarra. XGH em sua melhor forma. Só pra eu ter um "debug" pra olhar dentro do programa. 

  
def main():
    now = time.ctime(time.time())
    print(f"Starting: {now}")
    DNS = get_latest_ips()
    DNS = apply_translate(DNS)
    debug(DNS)
    status = check_for_update(DNS)
    if status:
        if len(sys.argv) > 1 and sys.argv[-1] == "--help":
            print(f"Use: {sys.argv[0]}  [--help|--dry-run]")
            sys.exit(0)
        if len(sys.argv) > 1 and sys.argv[-1] == "--dry-run":
            doDryRun = True
        else:
            doDryRun = False
        update_timestamp(dryrun=doDryRun)
        bind_restart(dryrun=doDryRun)

if __name__ == '__main__':
    main()

A função main é o que chama tudo. Algumas coisas de tempo pra saber quando começa. E efetivamente a primeira chamada aqui: DNS = get_latest_ips(). Soa razoável olhar pra esse get_latest_ips() e imaginar que volta os últimos ips. Mas ip de quem? Com certeza tem de voltar algo como um dicionário pra você saber qual hostname tem qual ip. E esse DNS? Tinha de ser em maiúsculo? Definitivamente não. Variáveis em maiúsculo a gente deixa pra constantes como LOG. Mas seguimos...

Agora temos um DNS = apply_translate(DNS). Esse é um filtro que usa o TRANSLATE lá em cima: 

  
TRANSLATE = {
    "goosfraba" : "helio",
    "raspberrypi-masoso" : "rpi0",
    "raspberrypi1" : "rpi1",
    "raspberrypi2" : "rpi2",
    "raspberrypi3" : "rpi3"
    }

E isso é usado porque meu desktop, por exemplo, tem hostname "goosfraba". Mas eu quero que ele seja no fqdn como "helio.truta.org". Então eu uso essa "tradução" de hostname recebido pro que eu quero no dns.

status = check_for_update(DNS) eu provavelmente comparo com o que está em DNSCONF. E se houve alteração, salvo em status. Definitivamente um boolean.

Em seguinda essa parte aqui: 

  
    if status:
        if len(sys.argv) > 1 and sys.argv[-1] == "--help":
            print(f"Use: {sys.argv[0]}  [--help|--dry-run]")
            sys.exit(0)
        if len(sys.argv) > 1 and sys.argv[-1] == "--dry-run":
            doDryRun = True
        else:
            doDryRun = False

Esse é um outro XGH. Tudo pra ver se existe o parâmetro "--help". Ou se é passado "--dry-run". "dry-run" é como é chamado um "test pra ver se vai" sem realmente fazer nada. Eu provavelmente fiz isso porque a primeira implementação era em shell script. Mas mesmo em shell script isso seria XGH.

update_timestamp(dryrun=doDryRun) faz aquele update de serial nos mapas de dns se algo mudou. A menos que o parâmetro de "dry-run" esteja lá.

E finalmente bind_restart(dryrun=doDryRun) reinicia o serviço via systemd ser não for um "dry-run".

Olhamos a lógica do que deveria fazer. Agora vamos ver o que foi feito. Vamos começar com o get_latest_ips( ). 

  
def get_latest_ips():
    """
    Dictionary in format:
        Domain/node : [ ipv4, ipv6]
    """
    debug("get_latest_ips()")
    NODE_IP = {}
    with open(LOG) as logfile:
        for line in logfile.readlines():
            if not re.search("\/\?update_dyndns=", line):
                continue
            line = re.sub(" HTTP.*", "", line)
            param = line.split()
            ip = param[0]
            nodename = re.sub("\/\?update_dyndns=", "", param[-1])

            if not nodename in NODE_IP:
                NODE_IP[nodename] = [ None, None ]
            # ipv4?
            if re.search("([0-9].*)\.([0-9].*)\.([0-9].*)\.([0-9].*)", ip):
                NODE_IP[nodename][0] = ip
                debug(f"{nodename} (ipv4): {ip}")
            else:
                NODE_IP[nodename][1] = ip
                debug(f"{nodename} (ipv6): {ip}")
    return NODE_IP

Aparentemente a estrutura NODE_IP = {} vai ser um dicionário do tipo hostname: [IPv4][IPv6]. 

  
    with open(LOG) as logfile:
        for line in logfile.readlines():
            if not re.search("\/\?update_dyndns=", line):
                continue

Aqui é ler o aquivo LOG. Se a linha não tiver o padrão "/?update_dynds=", vai pra próxima linha. 

  
            line = re.sub(" HTTP.*", "", line)
            param = line.split()
            ip = param[0]
            nodename = re.sub("\/\?update_dyndns=", "", param[-1])

A alinha recebida é algo assim: 

  83.233.219.150 - - [11/Aug/2025:08:54:57 +0000] "GET /?update_dyndns=goosfraba HTTP/1.1" 200 87144 "-" "curl/8.15.0"

Então o regex em line = re.sub(" HTTP.*", "", line) remove tudo depois de " HTTP", including essa parte junto. A linha então fica algo assim: 

  83.233.219.150 - - [11/Aug/2025:08:54:57 +0000] "GET /?update_dyndns=goosfraba

A linha param = line.split() cria a variável param (parâmetros) com a linha separada por espaços simples. ip = param[0] pega o primeiro parâmetro. No exemplo seria "83.233.219.150". nodename = re.sub("\/\?update_dyndns=", "", param[-1]) pega o último parâmetro, que no exemplo seria "/?update_dyndns=goosfraba" e remove a parte "/?update_dyndns=". Vai sobrar o hostname, "goosfraba". 

  
            if not nodename in NODE_IP:
                NODE_IP[nodename] = [ None, None ]

Aqui olha se o dicionário NODE_IP tem a chave que é o nodename. Eu comentei acima hostname, mas no código chamei de nodename. Tenha em mente que eram a mesma coisa. E se a chave não existe, eu crio com uma lista vazia. 

  
            if re.search("([0-9].*)\.([0-9].*)\.([0-9].*)\.([0-9].*)", ip):
                NODE_IP[nodename][0] = ip
                debug(f"{nodename} (ipv4): {ip}")
            else:
                NODE_IP[nodename][1] = ip
                debug(f"{nodename} (ipv6): {ip}")

Finalmente eu comparo o ip se bate com o padrão ([0-9].*)\.([0-9].*)\.([0-9].*)\.([0-9].*) que é basicamente qualquer número de 0 à 9 seguido de ponto. Então se eu recebesse um IP inválido, como 999.9999999.999999999999.99999999, validaria. Mas pro script XGH, foi suficiente. Daí eu sei se é um IPv4. Se não for, é IPv6.

Como vou lendo o arquivo LOG de cima pra baixo, esses valores de hostname e ip é atualizado várias vezes. Com os mesmos valores. E como o servidor web atualiza também de cima pra baixo, a última linha deve ser a mais atual. Não muito eficiente, mas dá certo. XGH raiz.

O apply_translate( ) eu não vou comentar. Já expliquei acima o que ele faz, que é traduzir hostname pra entrada no dns. Não adiciona muita coisa. Então vamos pro próximo.

O próximo é um XGH raiz. Função grande. É a check_for_update( ). Vamos por partes. 

  
def check_for_update(DIC):
    debug("check_for_update()")
    isupdated = False
    buf = ""
    debug("check_for_update(): current DNS entries")
    with open(DNSCONF) as fh:
        for line in fh.readlines():
            if line.startswith(";") or line.startswith("#"):
                buf += line
                continue
            line = line.rstrip()
            param = line.split()
            if len(param) != 3:
                buf += f"{line}\n"
                continue

Aqui é lido o arquivo DNSCONF, que é onde está o mapa "ip tipo nome" como "1.2.3.4 A helio". Essa primeira parte descarta as linhas que começam ou com ";" ou com "#". Na verdade copia a linha como está em buf. A parte de baixo prepara a linha pra ser lida se tiver o padrão de ter ao menos 3 parâmetros quando separada por espaços. Se não for, copie pro buffer e vá pra próxima linha. 

  
            subname, subtype, subip = param
            print(f"DNS current entry: {subname}, Type: {subtype}, IP: {subip}")
            if not subname in DIC:
                debug(f"check_for_update(): {subname} is not into the DIC")
                buf += f"{line}\n"
                continue

Aqui já pega os 3 parâmetros que serão subname, subtype, subip. O subname é o hostname. Ou nodename. Consistência não é meu forte. Ou não era. E se esse hostname não estiver no dicionário, salva a linha como ela era no buffer e vai pra próxima linha. 

  
            ipv4, ipv6 = DIC[subname]
            print(f"Found {subname} for update")
            # ipv4
            if subtype == "A":
                print("Checking IPv4")
                if ipv4 != subip and len(ipv4) > 0:
                    print(f" * Updating {subname} from {subip} to {ipv4}")
                    isupdated = True
                    buf += f"{subname}\t\t\t{subtype}\t{ipv4}\n"
                    continue
            # ipv6
            if subtype == "AAAA":
                print("Checking IPv6")
                if ipv6 != subip and len(ipv6) > 0:
                    print(f" * Updating {subname} from {subip} to {ipv6}")
                    isupdated = True
                    buf += f"{subname}\t\t\t{subtype}\t{ipv6}\n"
                    continue
            buf += f"{line}\n"

Aqui os endereços IPv4 e IPv6 são recuperados do dicionário em ipv4, ipv6 = DIC[subname]. Se o subtipo for "A", eu olho se o endereço IPv4 mudou. Se for "AAAA", olho o IPv6. Se alterar, eu altero isupdated pra verdadeiro. 

  
        if isupdated:
            print(f"Updating file {DNSCONF}")
            debug("check_for_update(): buf:", buf)
            with open(DNSCONF, 'w') as fh:
                fh.write(buf)
        return isupdated

E finalmente, se o código foi alterado, escrevo em cima do arquivo antigo o conteúdo novo.

Até aqui tudo bem. O código está meio rebuscado e com alguns pontos de XGH mas parece funcional. Vamos então olhar a próxima parte, que é atualizar os mapas caso tenha tido alguma mudança. Olhando pra update_timestamp( ) vamos ver que esse depende de outras funções, que ficam pra cima no código. E aqui já entra um pequeno mal estar. Eu gosto dos conselhos do Uncle Bob sobre clean code. E prefiro ler um código de cima pra baixo. Usou uma função ou método? Coloque abaixo. Na ordem em que foi chamado. Mas com python com funções isso não funciona. Você tem de colocar acima as funções que serão chamadas abaixo. Então vamos lá. 

  
  def update_timestamp(dryrun=False):
    debug("update_timestamp()")
    buf = ""
    today = time.strftime("%Y%m%d", time.localtime())

    timestamp = get_dns_map_serial(DNSDATE)

Bem básico. Pega o dia de hoje no formato "YYYMMDD". Em seguida olha qual o serial do arquivo com get_dns_map_serial( ). Ao contrário do que fiz até agora, eu vou parar de analizar essa função e seguir o código que ela chamou. 

  
def get_dns_map_serial(dns_file: str) -> str:
    with open(dns_file) as fh:
        for line in fh.readlines():
            if not re.search(" ; serial", line):
               continue
            timestamp = line.split()[0] 
            return timestamp
    raise Exception(f"Failed to read serial from dns file: {dns_file}")

Esse trecho de código é claramente mais recente. Usando f-strings e mais type hints pra saber o que seria ali. E variáveis em minúsculas! E bem simples: abre o arquivo passado (um mapa de dns) e busca pela linha com "; serial". Quebra a linha em espaços e retorna o primeiro parâmetro encontrado. Não tem verificação se realmente voltou uma string, mas parece ser isso. E se não achar nada, lança uma exceção e para a execução toda. Um pouco demais, mas pelo menos não retorna algo errado e deixa destruir o mapa de dns.

Vamos então voltar a olhar a função chamadora, update_timestamp( ). 

  
    (last_update, last_serial) = get_serial_date_update(timestamp)

Novamente um código mais enxuto. Ao invés de manter no corpo da função, chamar outra função auto-explicativa. Então vamos olhar a get_serial_date_update( ). 

  
def get_serial_date_update(timestamp: str) -> list:
    if len(timestamp) != 10 :
        raise Exception(f"Wrong timestamp size (not 10): {timestamp}") 
    dateformat = timestamp[:8]
    serial = timestamp[8:]
    return (serial)

Aqui ele verifica se o serial tem 10 caractéres, ou 10 dígitos com if len(timestamp) != 10. Ou gera uma exceção e encerra a execução. Pega os primeiro 8 caractéres e coloca em dateformat. Em seguida pega os caractéres restantes e coloca em serial. E retorna o serial.

Perceberam os problemas?

Já começa que a função chama-se get_serial_date_update( ). Qual o update? E deveria retornar uma lista. Até volta, mas com um valor só, o serial.

A função que chamava esperava o quê? Esperava isso aqui: (last_update, last_serial) = get_serial_date_update(timestamp). Então recebe last_update mas não last_serial. Achamos um 🪲.

Vamos então continuar em update_timestamp( ). 

  
    print("Timestamp:", timestamp)
    print("Last update:", last_update)
    print("Last serial:", last_serial)
    original_timestamp = ""
    if int(today) > int(last_update):
       timestamp = f"{today}00"
    else:
      serial = int(last_serial) + 1
      if serial < 100:
         timestamp = "%s%02d" % (today, serial)
      else:
         timestamp = "%08d00" % (int(today) + 1)
      print("New timestamp:", timestamp)

Aqui a data today é transformada em int (integer, inteiro) e comparada com last_update, que também é transformado em int. Se for maior, mais atual, então inicializa com "00". Se não for mais atual, então incrementa o número serial em 1. E olha se for maior que 100, incializa o dia seguinte e começa com 00 de novo.

E finalmente: 

  
    if dryrun is False:
        update_serial_in_file(original_timestamp, timestamp, DNSDATE)

Se não está rodando em dry-run, rodar esse update_serial_in_file( ). Pelo nome é possível deduzer que seja trocar o serial antigo do arquivo pelo novo. Mas vamos olhar o código. 

  
def update_serial_in_file(old_serial: str, new_serial: str, filename: str) -> None:
    with open(filename) as fh:
        buf = fh.read()
    buf = re.sub(old_serial, new_serial, buf)
    with open(filename, 'w') as fw:
        fw.write(buf)

E sim, é basicamente isso mesmo. Ler o arquivo todo, trocar a string antiga pela nova, e salvar.

E com isso chegamos na parte final do script: 

  
           bind_restart(dryrun=doDryRun)

É bem descritivo e faz exatamente o que diz: reinicia o serviço de dns via systemd. 

  
def bind_restart(dryrun=False):
    #cmd = "systemctl restart named.service"
    ## reload is enough
    cmd = "systemctl reload named.service"
    if dryrun is False:
        subprocess.call(cmd.split())
    else:
        print("-= dry-run mode =-")
        print(f"Here command would be called: {cmd}")

Se teve paciência de ler até aqui, espero que tenha gostado e aprendido que esse código estava bem ruim. E o que seria um código bom? Com certeza um que seja legível de cima pra baixo. Até certo ponto porque python não é tão flexível assim. Sem delongas, vou mostrar o código novo. Depois vou explicando. 

  
#! /usr/bin/python3 -u
# -*- encoding: utf-8 -*-

"""
DNS updater.  It checks if hostname and IP are updated
on maps.  If not, update accordingly and reload bind.
"""
# grep "\/\?node=" /var/log/apache2/dyndns-access.log | sed "s/ HTTP.*//" | awk '{print $1, $NF}'

import re
import time
import os
import subprocess
import sys
import argparse
import logging

logger = logging.getLogger(__file__)
consoleOutputHandler = logging.StreamHandler()
logger.addHandler(consoleOutputHandler)
logger.setLevel(logging.INFO)

TRANSLATE = {
    "goosfraba" : "helio",
    "raspberrypi-masoso" : "rpi0",
    "raspberrypi1" : "rpi1",
    "raspberrypi2" : "rpi2",
    "raspberrypi3" : "rpi3"
    }


class DnsIPUpdate:
    '''
    A class that reads httpd logs for patterns in order to find a host IP,
    update dns file accordingly if needed and restart dns service if updated.

    '''
    def __init__(self, args: argparse.Namespace):
        self._logfile: str = args.logfile
        self._bindfiles: list = args.bindfiles.split(",")
        self._IPv4: dict = {}
        self._IPv6: dict = {}
        self._dryrun: bool = args.dryrun
        self._dyndnsfile: str = args.dyndnsfile
        self._fakesystemd: bool = args.fakesystemd
        # for the serial on the dns files
        self._year: str = time.strftime("%Y", time.localtime())
        self._month: str = time.strftime("%m", time.localtime())
        self._day: str = time.strftime("%d", time.localtime())

    def update(self):
        'run the update'
        matched_lines: list = self.getEntriesFromLogs()
        self._populateIPsData(matched_lines)
        logger.debug(f'IPv4s: {self._IPv4}')
        logger.debug(f'IPv6s: {self._IPv6}')
        self._applyTranslation()
        logger.debug(f'IPv4s: {self._IPv4}')
        logger.debug(f'IPv6s: {self._IPv6}')

        if not self._dryrun:
            resp: bool = self._updateDNSFiles()
            if resp is True:
                self._restartService()

    def getEntriesFromLogs(self) -> list:
        'return the matching lines from logging file'
        matches: list = []
        with open(self._logfile) as fd:
            for line in fd.readlines():
                if not re.search(r"\/\?update_dyndns=", line):
                    continue
                line = line.rstrip()
                logger.debug(f"found line in log: {line}")
                matches.append(line)
        return matches

    def _populateIPsData(self, matches):
        'fill the IPv4 and IPv6 structures with IPs and hostnames'
        for line in matches:
            ip_addr, _, _, timestamp, timezone, method, uri, http_version, status_code, size, _, user_agent = line.split()
            timestamp = timestamp[1:]
            timezone = timezone[:-1]
            method = method[1:]
            http_version = http_version[:-1]
            user_agent = user_agent[1:-1]

            logger.debug(f"ip={ip_addr} timestamp={timestamp} timezone={timezone} method={method} uri={uri} proto={http_version} status_code={status_code} size={size} agent={user_agent}")

            hostname = self._getHostName(uri)

            if self._isIPv4(ip_addr):
                self._IPv4[hostname] = ip_addr
            else:
                self._IPv6[hostname] = ip_addr

    def _isIPv4(self, ip: str) -> bool:
        'quickly finds out whether IPv4 or not - then IPv6'
        if re.search("^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$", ip):
            return True
        return False

    def _getHostName(self, uri: str) -> str:
        'filter uri to return only the hostname'
        hostname = re.sub(r",.*", "", uri)
        hostname = re.sub(r".*update_dyndns=", "", hostname)
        return hostname

    def _applyTranslation(self) -> None:
        'translate hostname according to table'
        for old_name, new_name in TRANSLATE.items():
            if old_name in self._IPv4:
                logger.debug(f"Translating IPv4: from={old_name} to={new_name}")
                self._IPv4[new_name] = self._IPv4[old_name]
                del self._IPv4[old_name]
            if old_name in self._IPv6:
                logger.debug(f"Translating IPv6: from={old_name} to={new_name}")
                self._IPv6[new_name] = self._IPv6[old_name]
                del self._IPv6[old_name]

    def _updateDNSFiles(self) -> bool:
        'check and update DNS files if needed'
        isUpdated = self._updateDynDNS()
        if isUpdated is True:
            self._updateSerialOnDNS()
        return isUpdated

    def _updateDynDNS(self) -> bool:
        'check each entry into dyndns file and returns true if updated'
        status = False  # by default we don't update
        output = []
        with open(self._dyndnsfile) as fd:
            buffer = fd.readlines()

        for line in buffer:
            line = line.rstrip()  # remove new line
            try:
                hostname, _, _, dns_type, ip_addr = line.split("\t")
            except ValueError:
                output.append(f"{line}\n")
                continue

            match dns_type:
                case "A":
                    # IPv4
                    if hostname in self._IPv4:
                        if self._IPv4[hostname] != ip_addr:
                            logger.info(f"updating IPv4 for {hostname}: old={ip_addr} new={self._IPv4[hostname]}")
                            line = f"{hostname}\t\t\tA\t{self._IPv4[hostname]}"
                            status = True
                case "AAAA":
                    # IPv6
                    if hostname in self._IPv6:
                        if self._IPv6[hostname] != ip_addr:
                            logger.info(f"updating IPv6 for {hostname}: old={ip_addr} new={self._IPv6[hostname]}")
                            line = f"{hostname}\t\t\tAAAA\t{self._IPv6[hostname]}"
                            status = True
                case _:
                    pass
            output.append(f"{line}\n")

        if status is True:
            with open(self._dyndnsfile, 'w') as fw:
                fw.write("".join(output))

        return status

    def _updateSerialOnDNS(self) -> None:
        for filename in self._bindfiles:
            buffer: list = []
            logger.debug(f"updating serial on file: {filename}")
            with open(filename) as fd:
                for line in fd.readlines():
                    if not re.search("; serial", line):
                        buffer.append(line)
                        continue
                    line = line.rstrip()
                    logger.debug(f"line with serial number: {line}")
                    serial = self._sanitizeSerial(line)
                    logger.debug(f"serial={serial}")

                    new_serial = self._increaseSerial(serial)
                    logger.debug(f"new_serial={new_serial}")
                    line = f"\t\t\t\t{new_serial} ; serial\n"
                    logger.info(f"updating: filename={filename} old_serial={serial} new_serial={new_serial}")
                    buffer.append(line)
            with open(filename, "w") as fw:
                fw.write("".join(buffer))

    def _sanitizeSerial(self, serial_nr: str) -> str:
        'to remove the \t and spaces'
        serial, _ = serial_nr.split(";")
        serial = re.sub(r"\t", "", serial)
        serial = re.sub(" ", "", serial)
        return serial

    def _increaseSerial(self, serial_nr: str):
        'to identify and increase serial'
        year = serial_nr[:4]
        month = serial_nr[4:6]
        day = serial_nr[6:8]
        counter = serial_nr[8:]

        today = f"{self._year}{self._month}{self._day}"
        serial_date = f"{year}{month}{day}"
        if today == serial_date:
            new_counter = self._increaseString(counter)
            return f"{today}{new_counter}"
        else:
            return f"{today}00"

    def _increaseString(self, str_number: str) -> str:
        'convert string to int, increase by one and return as string'
        int_number: int = int(str_number)
        int_number += 1
        return f"{int_number}"

    def _restartService(self) -> None:
        'restart systemd service'
        cmd = ["systemctl", "reload", "named.service"]
        logger.info("restarting named.service")
        if self._fakesystemd is True:
            print(f"here service would be restarted: {cmd}")
        else:
            subprocess.call(cmd)


def getTimestamp():
    return time.strftime("%Y%m%dT%H:%M:%S", time.localtime())


def main():
    logger.info(f"starting: {getTimestamp()}")

    parser = argparse.ArgumentParser(description='script to update DNS entries for dynamic clients found on httpd logs')
    parser.add_argument("--logfile", required=True, help="the httpd log to be checked")
    parser.add_argument("--loglevel", default="info", help="logging level for this script")
    parser.add_argument("--bindfiles", required=True, help="files separated by \",\" to be updated to update serial")
    parser.add_argument("--dyndnsfile", required=True, help="the dyndns map to update the IPs")
    parser.add_argument("--dryrun", default=False, type=bool, help='run as dry-run or not (default=false)')
    parser.add_argument("--fakesystemd", default=False, type=bool, help='run just a printout instead of systemd')

    args = parser.parse_args()

    if args.loglevel != "info":
        logger.setLevel(args.loglevel.upper())

    logger.debug(f"args: {args}")

    dns = DnsIPUpdate(args)
    dns.update()

    logger.info(f"finished: {getTimestamp()}")


if __name__ == '__main__':
    main()

A parte de baixo continua mais ou menos igual: chama uma função main( ) que faz tudo. Mas agora a função main( ) usa argparse pra pegar os argumentos. Então as constantes com os nomes dos arquivos sumiram e viraram agora argumentos. Isso facilita escrever testes (o que não fiz ainda). O que o código faz? Faz isso aqui: 

  
    dns = DnsIPUpdate(args)
    dns.update()

Cria um objeto DnsIPUpdate( ) e chama o método update( ). Não mais funções mas métodos. Parece mais simples de entender. Espero.

Vamos então agora olhar a classe. Começando com sua inicialização. 

  
    def __init__(self, args: argparse.Namespace):
        self._logfile: str = args.logfile
        self._bindfiles: list = args.bindfiles.split(",")
        self._IPv4: dict = {}
        self._IPv6: dict = {}
        self._dryrun: bool = args.dryrun
        self._dyndnsfile: str = args.dyndnsfile
        self._fakesystemd: bool = args.fakesystemd
        # for the serial on the dns files
        self._year: str = time.strftime("%Y", time.localtime())
        self._month: str = time.strftime("%m", time.localtime())
        self._day: str = time.strftime("%d", time.localtime())

As variáveis (atributos da classe) vêm do argparse. Todas com o "_" no início pra indicar que são internas. Não que isso importe muito uma vez que não é uma classe feita pra ser usada como biblioteca. E agora IPv4 e IPv6 são estruturas separadas. Do tipo dicionário. E pegamos ano, mês e dia separados.

Vamos então olhar o método chamado, o update( ): 

  
    def update(self):
        'run the update'
        matched_lines: list = self.getEntriesFromLogs()
        self._populateIPsData(matched_lines)
        logger.debug(f'IPv4s: {self._IPv4}')
        logger.debug(f'IPv6s: {self._IPv6}')
        self._applyTranslation()
        logger.debug(f'IPv4s: {self._IPv4}')
        logger.debug(f'IPv6s: {self._IPv6}')

        if not self._dryrun:
            resp: bool = self._updateDNSFiles()
            if resp is True:
                self._restartService()

Primeiramente que o método update( ) aparece logo abaixo da inicialização da classe. Então você lê o código de cima pra baixo, o que é muito desejado. E o código chama outro método em matched_lines: list = self.getEntriesFromLogs( ), que vai retornar uma lista. Vamost então olhar o que faz getEntriesFromLogs( ). 

  
   def getEntriesFromLogs(self) -> list:
        'return the matching lines from logging file'
        matches: list = []
        with open(self._logfile) as fd:
            for line in fd.readlines():
                if not re.search(r"\/\?update_dyndns=", line):
                    continue
                line = line.rstrip()
                logger.debug(f"found line in log: {line}")
                matches.append(line)
        return matches

Ele então abre o arquivo _logfile e guarda as linhas com o padrão "/?update_dyndns=". E em formate de lista. Depois retorna esses valores. Não melhorou muito em termos de ler o arquivo todo e fazer o parsing de tudo. Ficou só mais legível.

Voltando ao update( ) temos logo em seguida: self._populateIPsData(matched_lines). Então vamos olhar o código de _populateIPsData( ). 

  
    def _populateIPsData(self, matches):
        'fill the IPv4 and IPv6 structures with IPs and hostnames'
        for line in matches:
            ip_addr, _, _, timestamp, timezone, method, uri, http_version, status_code, size, _, user_agent = line.split()
            timestamp = timestamp[1:]
            timezone = timezone[:-1]
            method = method[1:]
            http_version = http_version[:-1]
            user_agent = user_agent[1:-1]

            logger.debug(f"ip={ip_addr} timestamp={timestamp} timezone={timezone} method={method} uri={uri} proto={http_version} status_code={status_code} size={size} agent={user_agent}")

            hostname = self._getHostName(uri)

            if self._isIPv4(ip_addr):
                self._IPv4[hostname] = ip_addr
            else:
                self._IPv6[hostname] = ip_addr

Agora a linha é quebrada em espaços mas o dados são utilizados. O que é "_" significa que seja descartado. Então olhando a linha de exemplo novamente: 

  83.233.219.150 - - [11/Aug/2025:08:54:57 +0000] "GET /?update_dyndns=goosfraba HTTP/1.1" 200 200 "-" "curl/8.15.0"

Temos:

  • ip_addr=83.233.219.150
  • _=-
  • _=-
  • timestamp=[11/Aug/2025:08:54:57
  • timezone=+0000]
  • method="GET
  • uri=/?update_dyndns=goosfraba
  • http_version=HTTP/1.1"
  • status_code=200
  • size=200
  • _="-"
  • user_agent="curl/8.15.0"

O que vem a seguir é somente pra limpar esses parâmetros. Servem pra alguma coisa? Não. Só pra ficar bonitinho no debug. O que realmente importa são os valores de ip_addr e uri.

Em seguida é chamado hostname = self._getHostName(uri). Vamos olhar o código do _getHostName( ). 

  
    def _getHostName(self, uri: str) -> str:
        'filter uri to return only the hostname'
        hostname = re.sub(r",.*", "", uri)
        hostname = re.sub(r".*update_dyndns=", "", hostname)
        return hostname

É somente o mesmo sanitizador usado anteriormente. Vai remover o "/?update_dyndns=" e deixar somente o hostname.

Voltando ao _populateIPsData( ), temos a chamada if self._isIPv4(ip_addr): pra verificar se é um endereço IPv4 ou não. 

  
   def _isIPv4(self, ip: str) -> bool:
        'quickly finds out whether IPv4 or not - then IPv6'
        if re.search("^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$", ip):
            return True
        return False

O código agora olha se é um número válido dentro do range de IPv4.

Então após essa verificação, ou o dicionário _IPv4 ou o _IPv6 é populado. E segue o formato "hostname: IP". Mas cada um em seu dicionário agora.

Voltando ao update( ) temos: 

  
        logger.debug(f'IPv4s: {self._IPv4}')
        logger.debug(f'IPv6s: {self._IPv6}')
        self._applyTranslation()
        logger.debug(f'IPv4s: {self._IPv4}')
        logger.debug(f'IPv6s: {self._IPv6}')

Que é a mesmo tradução feita anteriormente. 

  
   def _applyTranslation(self) -> None:
        'translate hostname according to table'
        for old_name, new_name in TRANSLATE.items():
            if old_name in self._IPv4:
                logger.debug(f"Translating IPv4: from={old_name} to={new_name}")
                self._IPv4[new_name] = self._IPv4[old_name]
                del self._IPv4[old_name]
            if old_name in self._IPv6:
                logger.debug(f"Translating IPv6: from={old_name} to={new_name}")
                self._IPv6[new_name] = self._IPv6[old_name]
                del self._IPv6[old_name]

Seguindo em frente no update( ) temos o seguinte: 

  
        if not self._dryrun:
            resp: bool = self._updateDNSFiles()

Vamos olhar então _updateDNSFiles( ) que faz o update já visto anteriormente. 

  
   def _updateDNSFiles(self) -> bool:
        'check and update DNS files if needed'
        isUpdated = self._updateDynDNS()
        if isUpdated is True:
            self._updateSerialOnDNS()
        return isUpdated

Ele chama _updateDynDNS( ). Vamos então ao código. 

  
    def _updateDynDNS(self) -> bool:
        'check each entry into dyndns file and returns true if updated'
        status = False  # by default we don't update
        output = []
        with open(self._dyndnsfile) as fd:
            buffer = fd.readlines()

        for line in buffer:
            line = line.rstrip()  # remove new line
            try:
                hostname, _, _, dns_type, ip_addr = line.split("\t")
            except ValueError:
                output.append(f"{line}\n")
                continue

Então ele abre o arquivo e lê linha por linha. Mas dessa vez tenta popular a estrutura: hostname, _, _, dns_type, ip_addr = line.split("\t"). Se der errado, joga a linha no que será escrito depois. E segue pra próxima linha. Continuando. 

  
            match dns_type:
                case "A":
                    # IPv4
                    if hostname in self._IPv4:
                        if self._IPv4[hostname] != ip_addr:
                            logger.info(f"updating IPv4 for {hostname}: old={ip_addr} new={self._IPv4[hostname]}")
                            line = f"{hostname}\t\t\tA\t{self._IPv4[hostname]}"
                            status = True
                case "AAAA":
                    # IPv6
                    if hostname in self._IPv6:
                        if self._IPv6[hostname] != ip_addr:
                            logger.info(f"updating IPv6 for {hostname}: old={ip_addr} new={self._IPv6[hostname]}")
                            line = f"{hostname}\t\t\tAAAA\t{self._IPv6[hostname]}"
                            status = True
                case _:
                    pass

Usa match ao invés de um if. Poderia usar if? Sim. Mas achei que o match deixou o código mais organizado. Em seguida verifica se o hostname existe no dicionário de IP. Se existir, compara se o IP está diferente ou não. Se estiver, atualiza a flag status pra verdadeiro pra avisar que houveram mudanças. 

  
          output.append(f"{line}\n")

        if status is True:
            with open(self._dyndnsfile, 'w') as fw:
                fw.write("".join(output))

        return status

A parte final é salvar o arquivo caso tenha havido alguma alteração.

Voltando para _updateDNSFiles( ), temos: 

  
      if isUpdated is True:
            self._updateSerialOnDNS()
        return isUpdated

Vamos então olhar _updateSerialOnDNS( ): 

  
   def _updateSerialOnDNS(self) -> None:
        for filename in self._bindfiles:
            buffer: list = []
            logger.debug(f"updating serial on file: {filename}")
            with open(filename) as fd:
                for line in fd.readlines():
                    if not re.search("; serial", line):
                        buffer.append(line)
                        continue
                    line = line.rstrip()
                    logger.debug(f"line with serial number: {line}")
                    serial = self._sanitizeSerial(line)
                    logger.debug(f"serial={serial}")

                    new_serial = self._increaseSerial(serial)
                    logger.debug(f"new_serial={new_serial}")
                    line = f"\t\t\t\t{new_serial} ; serial\n"
                    logger.info(f"updating: filename={filename} old_serial={serial} new_serial={new_serial}")
                    buffer.append(line)
            with open(filename, "w") as fw:
                fw.write("".join(buffer))

Aqui já virou feijão com arroz. O que temos de olhar é _sanitizeSerial( ), depois _increaseSerial( ). 

  
   def _sanitizeSerial(self, serial_nr: str) -> str:
        'to remove the \t and spaces'
        serial, _ = serial_nr.split(";")
        serial = re.sub(r"\t", "", serial)
        serial = re.sub(" ", "", serial)
        return serial

Sem surpresas, só um regex pra voltar o número serial. 

  
   def _increaseSerial(self, serial_nr: str):
        'to identify and increase serial'
        year = serial_nr[:4]
        month = serial_nr[4:6]
        day = serial_nr[6:8]
        counter = serial_nr[8:]

        today = f"{self._year}{self._month}{self._day}"
        serial_date = f"{year}{month}{day}"
        if today == serial_date:
            new_counter = self._increaseString(counter)
            return f"{today}{new_counter}"
        else:
            return f"{today}00"

Aqui o código mudou. Ao invés de comparar com números inteiros, faz uma comparação de string direto. E chama _increaseString( ) pra aumentar o valor da string. 

  
   def _increaseString(self, str_number: str) -> str:
        'convert string to int, increase by one and return as string'
        int_number: int = int(str_number)
        int_number += 1
        return f"{int_number}"

Aqui sim a string é convertida pra inteiro. Esse é incrementado por 1. Mas retorna como string.

Chegamos então na parte final do update( ) que chama o método _restartService(). 

  
    def _restartService(self) -> None:
        'restart systemd service'
        cmd = ["systemctl", "reload", "named.service"]
        logger.info("restarting named.service")
        if self._fakesystemd is True:
            print(f"here service would be restarted: {cmd}")
        else:
            subprocess.call(cmd)

Sem muita novidade, é o código pra reiniciar o serviço de dns via systemd.

E aqui acabamos com o código novo. O que achou? Eu achei melhor de manter. E funcionando sem bugs.

O próximo passo será escrever testes unitários pra ele ☺️.

Um vídeo excelente sobre o que é o fediverso

Details
Written by: Helio Loureiro
Category: Fediverso
Hits: 711

Roubartilhando um vídeo muito bom que a Fabs postou no Mastodon. Explica bastante o fediverso e a importância de estar ali.

Do original:

Só uma pequena nota: estou salvando o vídeo aqui porque as coisas costuma sumir na Internet. Então aqui ficar preservado o vídeo.

25 anos de loureiro.eng.br

Details
Written by: Helio Loureiro
Category: Blog
Hits: 681

Foram inicialmente 10 anos, descritos em 10 anos de Loureiro.Eng.BR.

Depois foram 20 anos, 20 anos de Loureiro.Eng.BR !!!

E chegamos aos 25 anos do site. Pra minha imensa surpresa e prazer pessoal.

Eu esperava chegar nessa marca? Jamais! E continuar escrendo com frequência? Bem, isso eu imaginei sim no início. Aliás achei que era bem mais fácil criar conteúdo do que realmente é.

De notas pessoais a mensagens de blog. Tentei colocar de tudo por aqui. E manter a chama viva. E a chama sobreviveu esse tempo todo. E não parece que vai apagar tão cedo.

Nos vemos daqui 5 anos.

E feliz aniversário pro site.

DNS4EU, um sistema de DNS da Europa

Details
Written by: Helio Loureiro
Category: Blog
Hits: 683

A Europa tem tentado manter sistemas independentes dos EUA. Não é algo de agora, mas sempre foi um dos pensamentos vigentes por aqui. Quem não lembra do projeto Galileu, pra subistutir o GPS dos americanos caso esse fosse desligado?

E isso tem sido mais acirrado ultimamente com os temas de soberania de dados. Sem falar no Trump. Esse sozinho é um caso à parte.

E uma das iniciativas da Europa é esses sistema de DNS independente de empresas americanas. Eu já adotei aqui em casa.

Seu browser é seguro?

Details
Written by: Helio Loureiro
Category: Blog
Hits: 726

A EFF, Eletronic Frontier Foundation, lançou uma iniciativa bem legal. Você pode acessar e testar se seu browser mantém seus dados seguros no sentido de privacidade.

Eu testei no meus Firefox, tanto dos computadores (laptops e desktop) tanto quanto no meu telefone. Todos passaram maravilhosamente seguros quanto a minha privacidade.

E você? Já testou seus browser?

Mais uma tentativa com python3.13 e python3.13t

Details
Written by: Helio Loureiro
Category: Python
Hits: 709

Resolvi aproveitar que meu desktop está menos sobrecarregado e rodar os testes novamente pra comparar com os do artigo anterior, revisitando o artigo de shell lento com python3.13. 

  
❯ time python3.13 20M-touch.py; time python3.13t 20M-touch.py 

________________________________________________________
Executed in  396.13 secs    fish           external
   usr time  231.65 secs  479.00 micros  231.65 secs
   sys time  158.26 secs  803.00 micros  158.26 secs


________________________________________________________
Executed in   22.31 mins    fish           external
   usr time  495.80 secs    0.00 millis  495.80 secs
   sys time  820.21 secs    1.22 millis  820.20 secs

De 621 pra 396s já foi um ganho significativo de desempenho. Mas abaixo dos 374s do primeiro artigo, shell é lento?

O python3.13t, quer permite desabilitar o GIL, continua lento. Eu esqueci de desabilitar o GIL e não deveria fazer diferença. Mas fez. 22 minutos. Melhor que os 31 minutos do artigo anterior.

E com GIL desabilitado? 

  
❯ time env PYTHON_GIL=0 python3.13t 20M-touch.py

________________________________________________________
Executed in   22.63 mins    fish           external
   usr time  506.53 secs  381.00 micros  506.53 secs
   sys time  822.23 secs  825.00 micros  822.23 secs

Não mudou muita coisa. O jeito é aceitar que é isso e seguir em frente. Segura o choro que dói menos.

Revisitando o artigo de shell lento com python3.13

Details
Written by: Helio Loureiro
Category: Python
Hits: 757

Quando escrevi o artigo Shell é lento? python teve uma performance miserável. Pra não chamar de outra coisa.

Resolvi então dar uma revisitada no teste e rodando o python3.13. A cada versão de python dizem que a performance é melhorada. Nada melhor que tirar a prova. E além disso a versão 3.13 permite desabilitar o GIL, o Global Interpreter Locker. Não se se faz alguma diferença num teste desses, mas vamos tentar.

Eu mantive o mesmo programa que rodei da outra vez: 

  
#! /usr/bin/env python3

for i in range(20000000):
    with open("arq-python3", "w") as fd:
        None

E o resultado: 

  
helio@goosfraba❯ time python3.13 20M-touch.py

________________________________________________________
Executed in  621.80 secs    fish           external
   usr time  384.60 secs  998.00 micros  384.60 secs
   sys time  229.78 secs    0.00 micros  229.78 secs

Demorou mais que o teste anterior. Se antes foi miserável, essa aqui... Mas antes de botar a culpa no Python, vamos rodar a versão em Go e olhar se os tempos mudaram. O código de Go também continua o mesmo: 

  
package main

import (
        "log"
        "os"
)

func main() {
        for i := 0; i < 20000000; i++ {
                fd, err := os.Create("arq-go")
                fd.Close()
                if err != nil {
                        log.Fatal(err)
                }
        }
}

E depois daquela compilada básica: 

  
helio@goosfraba❯ go build -o 20M-touch 20M-touch.go
helio@goosfraba❯ time ./20M-touch

________________________________________________________
Executed in  295.12 secs    fish           external
   usr time   88.50 secs    0.20 millis   88.50 secs
   sys time  199.48 secs    1.03 millis  199.47 secs

Realmente baixou o Exu-tranca-sistema no HDD. Da época em que fiz o primeiro teste pra cá a mudança foi a adição de um disco extra de 12 TB. E afetou bastante a performance. De 148s pra 295s com o binário em Go. Nesse caso é melhor rodar o este com cada linguagem pra ver as diferenças no sistema novo e ter um equilíbrio maior entre os resultados. 

  
helio@goosfraba❯ time perl 20M-touch.pl

________________________________________________________
Executed in  260.95 secs    fish           external
   usr time   61.45 secs    1.31 millis   61.45 secs
   sys time  195.20 secs    0.04 millis  195.20 secs  

helio@goosfraba❯ time bash 20M-touch.sh 

________________________________________________________
Executed in  443.89 secs    fish           external
   usr time  213.20 secs    1.26 millis  213.20 secs
   sys time  227.43 secs    0.04 millis  227.43 secs

E pra melhorar o escope de testes, adicionei ainda a versão em C++: 

  
#include <iostream>
#include <fstream>
using namespace std;

int main() {
  for (int i=0;i<20000000;i++) {
    ofstream MyFile("arq-cpp");
    MyFile.close();
  }
}

O resultado: 

  
helio@goosfraba❯ time ./20M-touch-cpp 

________________________________________________________
Executed in  205.39 secs    fish           external
   usr time   39.56 secs  359.00 micros   39.56 secs
   sys time  163.64 secs  911.00 micros  163.64 secs

O resultados foram então (do mais rápido pro mais lento):

  • c++: 205.39s
  • perl: 260.95s
  • go: 295.12s
  • bash: 443.89s
  • python: 621.80s

    • Enquanto C++ manteve a performance esperada, perl deu um show. Eu pessoalmente achei que Go! ficou devendo, ainda mais se comparado com C++. Mas python... python fracassou miseravelmente. E de novo.

    E fui tentar rodar com o GIL desabilitado e... 

      
helio@goosfraba❯ time env PYTHON_GIL=0 python3.13 20M-touch.py
Fatal Python error: config_read_gil: Disabling the GIL is not supported by this build
Python runtime state: preinitialized


________________________________________________________
Executed in    4.91 millis    fish           external
   usr time    2.03 millis    1.09 millis    0.95 millis
   sys time    2.85 millis    0.02 millis    2.83 millis

    Vou precisar compilar um python3.13 com a configuração que permite desabilitar o GIL...

    Update: compilei um pacote do AUR. 

      
==> Creating package "python313-freethreaded"...
  -> Generating .PKGINFO file...
  -> Generating .BUILDINFO file...
  -> Generating .MTREE file...
  -> Compressing package...
==> Leaving fakeroot environment.
==> Finished making: python313-freethreaded 3.13.3-1 (Mon 12 May 2025 06:04:15 PM CEST)
==> Cleaning up...

    E vamos aos resultados: 

      
helio@goosfraba❯ time env PYTHON_GIL=0 python3.13t 20M-touch.py

________________________________________________________
Executed in   31.58 mins    fish           external
   usr time   14.01 mins    0.00 millis   14.01 mins
   sys time   17.25 mins    1.96 millis   17.25 mins

    Python continua parecendo que bateu uma feijuca antes de rodar os testes. Não que remover o GIL fosse mudar muita coisa uma vez que o teste é sequencial. Mas podia ter melhorado um pouco.

    Enquanto isso também descobri o porquê dos testes estarem mais lentos: tem algum treco do yay compilando. Sei lá eu o que é uma vez que estou conectado remotamente.

    O ano do Linux no desktop está acontecendo!

    Details
    Written by: Helio Loureiro
    Category: Linux
    Hits: 756

    Sempre tenho renovado meus votos sobre o ano do Linux no desktop. E parece que dessa vez deu certo mesmo.

    Sem nenhuma ligação com comunidades Linux ou software livre, o influenciador digital "PewDiePie", com milhões de seguidores, simplemente resolveu migrar e enaltecer o uso do Linux. E não pense que foi pouca coisa. O cara já meteu uma variante do archlinux com hyperland.

    Simplesmente maravilhoso. Confira:

    Se ainda existisse FISL, era certeza que o PewDiePie era o próximo keynote. Quem sabe não seja no FOSDEM?

    Novo canal da Bárbara Tostes

    Details
    Written by: Helio Loureiro
    Category: Blog
    Hits: 693

    A querida Bárbara Tostes lançou esse vídeo anunciando seu novo canal e o trabalho que irá fazer por lá. Então aqui está minha contribuição em sua divulgação.

    E boa sorte para ela.

    Gerando senhas com openssl

    Details
    Written by: Helio Loureiro
    Category: Scripts
    Hits: 740

    Só um comando que uso bastante e provavelmente tem gente que nem sabe que existe.

    OpenSSL tem várias funcionalidades, entre elas gerar senhas. O comando que uso é o seguinte: 

      
❯ openssl rand -base64 32 | cut -c 1-43

    O resultado é algo como isso aqui (que a cada comando resulta em algo aleatório): 

      
❯ openssl rand -base64 32 | cut -c 1-43
EHjsiO2IIuaBzGmugiVDZgfmj83v/LqZ/nevZ5itzV0

    Configurando traefik com ssh

    Details
    Written by: Helio Loureiro
    Category: SRE - Site Reliability Engineer
    Hits: 977

    Esse parece ser um tópico um tanto quanto... distópico? Talvez nem tanto. Mas todas as referências sobre o assunto na Internet estão incompletos e geralmente são pra versões mais antigas do traefik. Traefik é um roteador de conexões que funciona tanto como programa chamado por systemd (ou outro sistema de init se for um BSD), ou por container com algo como docker-compose, ou ainda diretamente em kubernetes. E não só funciona como proxy-reverse: pode também atuar como um servidor http pra suas conexões. E não somente tcp como udp. E escrito em Go!

    Eu precisei colocar um servidor ssh atrás de um traefik. E deu um certo trabalho. Pra testar e mostrar aqui também, usei docker-compose pro serviço. Isso facilitou a configuração. Pra backend com ssh, subi uma instância do gitea com o ssh na porta 2222. Usei também certificados letsencrypt nas portas https do serviço.

    Como um plus, ainda adicionei um allowlist pra acessar o serviço somente de certos IPs.

    Vamos pra configuração então. Primeiramente do traefik. Pra subir, eu configurei pra ouvir nas portas 80 (http), 443 (https), 8080 (traefik dashboard) e 2222 (ssh). O conteúdo de traefik/docker-compose.yml: 

      
services:
  traefik:
    image: "traefik:v3.3"
    container_name: "traefik"
    restart: unless-stopped
    environment:
      - TZ=Europe/Stockholm
    ports:
      - "80:80"
      - "443:443"
      - "8080:8080"
      - "2222:2222"
    volumes:
      - "./letsencrypt:/letsencrypt"
      - "/var/run/docker.sock:/var/run/docker.sock:ro"
      - "./traefik.yml:/traefik.yml:ro"
    networks:
      - traefik

networks:
  traefik:
    name: traefik

    Junto com essa configuração de container, ainda inclui a configuração do serviço em traefik/traefik.yml: 

      
api:
  dashboard: true
  insecure: true
  debug: true
entryPoints:
  web:
    address: ":80"
    http:
      redirections:
        entryPoint:
          to: websecure
          scheme: https
  websecure:
    address: ":443"
  ssh:
    address: ":2222"
serversTransport:
  insecureSkipVerify: true
providers:
  docker:
    endpoint: "unix:///var/run/docker.sock"
    exposedByDefault: false
    network: traefik
certificatesResolvers:
  letsencrypt:
    acme:
      email: This email address is being protected from spambots. You need JavaScript enabled to view it.
      storage: /letsencrypt/acme.json
      httpChallenge:
        # used during the challenge
        entryPoint: web

log:
  level: WARN

    Aqui é possível ver que defino novamente os entrypoints pra 80, 443 e 2222. E no 80 (http) eu redireciono pro 443 (https). E certificado do letsencrypt.

    Tudo pronto no lado do traefik. Agora é o ponto de subir o serviço e preparar algumas coisas pra testar. 

      
# docker compose -p traefik -f traefik/docker-compose.yml up -d
[+] Running 1/1
 ✔ Container traefik  Started                                0.4s

    Dentro do diretório traefik será criado um diretório letsencrypt e dentro dele terá o arquivo acme.json com seus certificados.

    Primeiramente vamos subir um container de teste pra ver se tudo funciona. O próprio projeto traefik fornece um container chamado whoami pra isso. O conteúdo de whois/docker-compose.yml: 

      
services:
  whoami:
    container_name: simple-service
    image: traefik/whoami
    labels:
        - "traefik.enable=true"
        - "traefik.http.routers.whoami.rule=Host(`whoami.tests.loureiro.eng.br`)"
        - "traefik.http.routers.whoami.entrypoints=websecure"
        - "traefik.http.routers.whoami.tls=true"
        - "traefik.http.routers.whoami.tls.certresolver=letsencrypt"
        - "traefik.http.services.whoami.loadbalancer.server.port=80"
    networks:
        - traefik
networks:
  traefik:
    name: traefik

    E habilitando o serviço com docker-compose: 

      
# docker compose -p whoami -f whoami/docker-compose.yml up -d
WARN[0000] a network with name traefik exists but was not created for project "whoami".
Set `external: true` to use an existing network 
[+] Running 1/1
 ✔ Container simple-service  Started                                              0.3s

    E um simples teste do serviço: 

      
❯ curl -I http://whoami.tests.loureiro.eng.br
HTTP/1.1 308 Permanent Redirect
Location: https://whoami.tests.loureiro.eng.br/
Date: Thu, 24 Apr 2025 12:43:55 GMT
Content-Length: 18

❯ curl  https://whoami.tests.loureiro.eng.br
Hostname: 0da540e1039c
IP: 127.0.0.1
IP: ::1
IP: 172.18.0.3
RemoteAddr: 172.18.0.2:52686
GET / HTTP/1.1
Host: whoami.tests.loureiro.eng.br
User-Agent: curl/8.5.0
Accept: */*
Accept-Encoding: gzip
X-Forwarded-For: 1.2.3.4
X-Forwarded-Host: whoami.tests.loureiro.eng.br
X-Forwarded-Port: 443
X-Forwarded-Proto: https
X-Forwarded-Server: 4cacedb0129a
X-Real-Ip: 1.2.3.4

    O primeiro curl pro endpoint na porta 80 (http) recebe um redirect pra https. Perfeito! O segundo, os dados do container de forma transparente.

    O serviço funciona! Mas pra http e https. Falta ssh na porta 2222, que está nessa porta pra não atrapalhar o uso do ssh normal do sistema.

    Pra isso eu configurei um gitea, como descrevi no início do artigo. Seu docker-compose.yml é o seguinte: 

      
    services:
  server:
    image: gitea/gitea:1.23-rootless #latest-rootless
    container_name: gitea
    environment:
     - GITEA__database__DB_TYPE=postgres
     - GITEA__database__HOST=db:5432
     - GITEA__database__NAME=gitea
     - GITEA__database__USER=gitea
     - GITEA__database__PASSWD=A4COU5a6JF5ZvWoSufi0L1aomSkzqww7s1wv039qy6o=
     - LOCAL_ROOT_URL=https://gitea.tests.loureiro.eng.br
     - GITEA__openid__ENABLE_OPENID_SIGNIN=false
     - GITEA__openid__ENABLE_OPENID_SIGNUP=false
     - GITEA__service__DISABLE_REGISTRATION=true
     - GITEA__service__SHOW_REGISTRATION_BUTTON=false
     - GITEA__server__SSH_DOMAIN=gitea.tests.loureiro.eng.br
     - GITEA__server__START_SSH_SERVER=true
     - GITEA__server__DISABLE_SSH=false    
    restart: always
    volumes:
      - gitea-data:/var/lib/gitea
      - gitea-config:/etc/gitea
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    #ports:
    #  - "127.0.0.1:3000:3000"
    #  - "127.0.0.1:2222:2222"
    depends_on:
      - db
    networks:
      - traefik
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.giteaweb.rule=Host(`gitea.tests.loureiro.eng.br`)"
      - "traefik.http.routers.giteaweb.entrypoints=websecure"
      - "traefik.http.routers.giteaweb.tls=true"
      - "traefik.http.routers.giteaweb.tls.certresolver=letsencrypt"
      - "traefik.http.services.giteaweb.loadbalancer.server.port=3000"
      - "traefik.http.middlewares.giteaweb-ipwhitelist.ipallowlist.sourcerange=1.2.3.4, 4.5.6.7"
      - "traefik.http.routers.giteaweb.middlewares=giteaweb-ipwhitelist"
      - "traefik.tcp.routers.gitea-ssh.rule=HostSNI(`*`)"
      - "traefik.tcp.routers.gitea-ssh.entrypoints=ssh"
      - "traefik.tcp.routers.gitea-ssh.service=gitea-ssh-svc"
      - "traefik.tcp.services.gitea-ssh-svc.loadbalancer.server.port=2222"
      - "traefik.tcp.middlewares.giteassh-ipwhitelist.ipallowlist.sourcerange=1.2.3.4, 4.5.6.7"
      - "traefik.tcp.routers.gitea-ssh.middlewares=giteassh-ipwhitelist"

  db:
    image: postgres:17
    restart: always
    container_name: gitea_db
    environment:
      - POSTGRES_DB=gitea
      - POSTGRES_USER=gitea
      - POSTGRES_PASSWORD=A4COU5a6JF5ZvWoSufi0L1aomSkzqww7s1wv039qy6o=

    networks:
      - traefik
    volumes:
      - gitea-db:/var/lib/postgresql/data

networks:
  traefik:
    name: traefik

volumes:
  gitea-data:
  gitea-config:
  gitea-db:

    Pode ser visto que existe uma regra pra parte web, que roda na porta 3000 do container, e pra parte de ssh, que fica na porta 22222. Eu deixei comentado a parte que exporta as portas pra mostrar claramente que isso não é necessário. Aliás não funciona se especificar as portas.

    E finalmente rodando o serviço: 

      
# docker compose -p gitea -f gitea/docker-compose.yml up -d
WARN[0000] a network with name traefik exists but was not created for project "gitea".
Set `external: true` to use an existing network 
[+] Running 2/2
 ✔ Container gitea_db  Started                   0.3s 
 ✔ Container gitea     Started                   1.0s

    E vamos ao testes. 

      
❯ curl -s  https://gitea.tests.loureiro.eng.br | head -n 10
<!DOCTYPE html>
<html lang="en-US" data-theme="gitea-auto">
<head>
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <title>Gitea: Git with a cup of tea</title>
        <link rel="manifest" href="data:application/json;base64,eyJuYW1lIjoiR2l0ZWE6IEdpdCB3aXRoIGEgY3VwIG9mIHRlYSIsInNob3J0X25hbWUiOiJHaXRlYTogR2l0IHdpdGggYSBjdXAgb2YgdGVhIiwic3RhcnRfdXJsIjoiaHR0cDovL2xvY2FsaG9zdDozMDAwLyIsImljb25zIjpbeyJzcmMiOiJodHRwOi8vbG9jYWxob3N0OjMwMDAvYXNzZXRzL2ltZy9sb2dvLnBuZyIsInR5cGUiOiJpbWFnZS9wbmciLCJzaXplcyI6IjUxMng1MTIifSx7InNyYyI6Imh0dHA6Ly9sb2NhbGhvc3Q6MzAwMC9hc3NldHMvaW1nL2xvZ28uc3ZnIiwidHlwZSI6ImltYWdlL3N2Zyt4bWwiLCJzaXplcyI6IjUxMng1MTIifV19">
        <meta name="author" content="Gitea - Git with a cup of tea">
        <meta name="description" content="Gitea (Git with a cup of tea) is a painless self-hosted Git service written in Go">
        <meta name="keywords" content="go,git,self-hosted,gitea">
        <meta name="referrer" content="no-referrer">
❯ telnet gitea.tests.loureiro.eng.br 2222
Trying 1.2.3.4...
Connected to gitea.tests.loureiro.eng.br.
Escape character is '^]'.
SSH-2.0-Go

^]
telnet> q
Connection closed.

    E pronto! Temos o serviço funcionando e roteado pelo traefik. E podendo fazer ACL de ip do serviço sem precisar do firewall pra isso.

    Boa diversão!

    Nota: eu coloquei um básico da configuração do gitea pra exemplo. E não funciona se copiar e colar. Pra ter um serviço rodando, terá de adicionar mais algumas partes em environment.

    Script pra verificar e atualizar os certificados dos domínios com letsencrypt

    Details
    Written by: Helio Loureiro
    Category: Shell Scripts
    Hits: 1002

    Continuando os trabalhos do artigo Ferramenta pra verificar quantidades de dias válidos de um certificado do letsencrypt, fiz uma pequena entrada na crontab pra chamar um script que fiz em fish. 

      
# tail -1 /etc/crontab 
0  1  */5 * * root /root/bin/check-domain-expiration-dates.fish >> /tmp/certificate_renew.log 2>&1

    E o respectivo script: 

      
#! /usr/bin/env fish
set EXPIRATION_DAYS 10

for info in (letsencrypt-cert-days)
  set domain (echo $info | cut -d"=" -f1)
  set days (echo $info | cut -d"=" -f2)
  if [ $days -lt $EXPIRATION_DAYS ]
    echo "Renewing domain: $domain"
    certbot renew -d $domain
  end
end

    Então eu rodo no crontab a cada 5 dias pra detectar se algum certificado está expirando. E então chamo o `certbot` pra renovar se for o caso.

    Funciona? Não sei. Meus certificados estão válidos ainda por quase 50 dias. Daqui um mês eu atualizo se funcionou. 

      
# letsencrypt-cert-days --domain=helio.loureiro.eng.br
helio.loureiro.eng.br=48

    .oO(nota mental: trocar crontab por systemd-timer)

    Page 2 of 36

    Estatísticas

    • Users 2
    • Articles 475
    • Articles View Hits 3416007

    Imagem aleatória

    We use cookies

    We use cookies on our website. Some of them are essential for the operation of the site, while others help us to improve this site and the user experience (tracking cookies). You can decide for yourself whether you want to allow cookies or not. Please note that if you reject them, you may not be able to use all the functionalities of the site.

    Ok Decline