Post

Implementação de DNS Anycast com Containers

Posted
By Gean Martins
44 min read
Implementação de DNS Anycast com Containers

Implementação de DNS Anycast com Containers

Este é um tutorial complementar à nossa série sobre implementação e configuração do DNS BIND no Oracle Linux 9. Nos artigos anteriores, abordamos desde os conceitos fundamentais do DNS até a automação com Ansible e GitLab CI/CD e a containerização de servidores DNS. Agora, vamos explorar como implementar DNS Anycast em ambientes containerizados.

Introdução ao DNS Anycast

O DNS Anycast é uma técnica de roteamento de rede que permite anunciar o mesmo endereço IP a partir de múltiplos locais na internet. Quando um cliente envia uma consulta DNS para um endereço Anycast, a infraestrutura de roteamento da internet direciona a consulta para o servidor mais próximo topologicamente, o que geralmente resulta em menor latência e maior resiliência.

Combinar DNS Anycast com containerização oferece o melhor dos dois mundos: a distribuição geográfica e resiliência do Anycast com a portabilidade, isolamento e facilidade de implantação dos containers. Esta abordagem é particularmente valiosa para organizações com presença global ou infraestruturas distribuídas.

Neste tutorial, exploraremos como implementar DNS Anycast em ambientes containerizados, abordando desde os conceitos fundamentais até a implementação prática, incluindo configuração de roteamento, automação e monitoramento.

Conceitos Fundamentais do DNS Anycast

Antes de mergulharmos na implementação, vamos entender os conceitos fundamentais do DNS Anycast.

O que é Anycast?

Anycast é um método de endereçamento de rede onde o mesmo endereço IP é atribuído a múltiplos nós em diferentes locais. O tráfego destinado a esse endereço é roteado para o nó mais próximo do cliente, conforme determinado pelos protocolos de roteamento.

Existem três principais métodos de endereçamento de rede:

  1. Unicast: Um endereço IP corresponde a uma única interface de rede
  2. Multicast: Um endereço IP corresponde a múltiplas interfaces de rede, com pacotes entregues a todas elas
  3. Anycast: Um endereço IP corresponde a múltiplas interfaces de rede, mas pacotes são entregues apenas à mais próxima

Como o Anycast Funciona?

O Anycast funciona através dos protocolos de roteamento dinâmico, principalmente o BGP (Border Gateway Protocol). Cada nó Anycast anuncia o mesmo prefixo IP, e os roteadores da internet determinam o caminho mais curto para cada cliente com base em métricas como número de saltos, latência ou políticas de roteamento.

Como o Anycast Funciona?

O Anycast funciona através dos protocolos de roteamento dinâmico, principalmente o BGP (Border Gateway Protocol). Cada nó Anycast anuncia o mesmo prefixo IP, e os roteadores da internet determinam o caminho mais curto para cada cliente com base em métricas como número de saltos, latência ou políticas de roteamento.

+---------+      Consulta IP Anycast (192.0.2.53)      +-------------------+
| Cliente | -----------------------------------------> | Roteador Internet |
| (Europa)|                                            +--------+----------+
+---------+                                                     |
                                                                | Roteamento BGP
                               +--------------------------------+---------------------------------+
                               |                                |                                 |
                               V                                V                                 V
                        +------v----------+             +------v----------+              +------v----------+
                        | Servidor Anycast|             | Servidor Anycast|              | Servidor Anycast|
                        | (Europa)        |             | (América)       |              | (Ásia)          |
                        | IP: 192.0.2.53  |             | IP: 192.0.2.53  |              | IP: 192.0.2.53  |
                        +-----------------+             +-----------------+              +-----------------+
                               | (Mais Próximo)
                               V
                        +------v----------+ 
                        | Resposta DNS    |
                        +-----------------+
                               |
                               V
+---------+      Resposta DNS                             +-------------------+
| Cliente | <------------------------------------------ | Roteador Internet |
| (Europa)|                                             +-------------------+

Figura 1: Funcionamento do Anycast

O DNS Anycast oferece diversos benefícios:

  1. Redução de latência: Consultas são respondidas pelo servidor mais próximo
  2. Alta disponibilidade: Se um servidor falhar, as consultas são automaticamente roteadas para o próximo servidor mais próximo
  3. Distribuição de carga: O tráfego é naturalmente distribuído entre os servidores
  4. Mitigação de DDoS: Ataques são distribuídos entre múltiplos servidores, diluindo seu impacto
  5. Simplicidade para clientes: Clientes usam um único endereço IP, sem necessidade de configuração complexa

Desafios do DNS Anycast

Apesar dos benefícios, o DNS Anycast também apresenta desafios:

  1. Complexidade de roteamento: Requer conhecimento de BGP e outros protocolos de roteamento
  2. Consistência de estado: Difícil manter estado consistente entre servidores Anycast
  3. Monitoramento: Mais complexo monitorar serviços distribuídos geograficamente
  4. Troubleshooting: Problemas podem ser específicos de determinadas regiões ou rotas

Arquitetura de DNS Anycast com Containers

Vamos explorar como combinar DNS Anycast com containers para criar uma arquitetura distribuída e resiliente.

Visão Geral da Arquitetura

Nossa arquitetura de DNS Anycast com containers consistirá em:

  1. Containers BIND: Executando o servidor DNS BIND
  2. Roteadores BGP: Anunciando os prefixos Anycast
  3. Orquestração de containers: Gerenciando o ciclo de vida dos containers
  4. Monitoramento: Verificando a saúde e desempenho dos servidores DNS
  5. Automação: Implantando e gerenciando a infraestrutura como código

Visão Geral da Arquitetura

Nossa arquitetura de DNS Anycast com containers consistirá em:

  1. Containers BIND: Executando o servidor DNS BIND
  2. Roteadores BGP: Anunciando os prefixos Anycast
  3. Orquestração de containers: Gerenciando o ciclo de vida dos containers
  4. Monitoramento: Verificando a saúde e desempenho dos servidores DNS
  5. Automação: Implantando e gerenciando a infraestrutura como código
+----------------------------------------------------------------------> Internet
|                                                                         ^
| BGP Peering                                                             | Consulta DNS (IP Anycast)
V                                                                         |
+-----------------+      +-----------------+      +-----------------+     +---------+
| Roteador BGP    |      | Roteador BGP    |      | Roteador BGP    |     | Cliente |
| (Local A)       |      | (Local B)       |      | (Local C)       |     +---------+
+-------+---------+      +-------+---------+      +-------+---------+
        |                        |                        |
        | Anuncia IP Anycast     | Anuncia IP Anycast     | Anuncia IP Anycast
        V                        V                        V
+-------+---------+      +-------+---------+      +-------+---------+
| Host Docker/K8s |      | Host Docker/K8s |      | Host Docker/K8s |
| (Local A)       |      | (Local B)       |      | (Local C)       |
| +-------------+ |      | +-------------+ |      | +-------------+ |
| | Container   | |      | | Container   | |      | | Container   | |
| | BIND        | |      | | BIND        | |      | | BIND        | |
| | IP Anycast  | |      | | IP Anycast  | |      | | IP Anycast  | |
| +-------------+ |      | +-------------+ |      | +-------------+ |
+-----------------+      +-----------------+      +-----------------+
       ^                                | Resposta DNS (do mais próximo)
       |--------------------------------+

Figura 2: Arquitetura de DNS Anycast com Containers

Containers BIND

Os containers BIND serão implantados em múltiplos locais, cada um configurado de forma idêntica para responder às mesmas consultas DNS. Usaremos a imagem Docker do BIND que desenvolvemos no tutorial anterior.

Roteamento BGP

Para implementar o Anycast, precisamos de um daemon BGP em cada local para anunciar os prefixos Anycast. Existem várias opções:

  1. Bird: Daemon de roteamento leve e flexível
  2. FRRouting (FRR): Suite de roteamento completa
  3. ExaBGP: Controlador BGP programável em Python

Neste tutorial, usaremos o Bird devido à sua simplicidade e eficiência.

Orquestração de Containers

Para gerenciar os containers, podemos usar:

  1. Docker Swarm: Para implantações mais simples
  2. Kubernetes: Para implantações mais complexas e em grande escala

Abordaremos ambas as opções neste tutorial.

Monitoramento

O monitoramento é crucial para uma infraestrutura DNS Anycast. Usaremos:

  1. Prometheus: Para coleta de métricas
  2. Grafana: Para visualização
  3. Blackbox Exporter: Para testes de disponibilidade
  4. BIND Exporter: Para métricas específicas do BIND

Automação

Para automação, continuaremos usando:

  1. Ansible: Para configuração e implantação
  2. GitLab CI/CD: Para pipelines de integração e entrega contínua

Fluxo de Consultas DNS

Em nossa arquitetura, o fluxo de consultas DNS será:

  1. Cliente envia consulta DNS para o endereço Anycast
  2. Roteadores da internet direcionam a consulta para o servidor Anycast mais próximo
  3. O container BIND nesse local processa a consulta
  4. A resposta é enviada de volta ao cliente

Preparação do Ambiente

Antes de implementar o DNS Anycast com containers, precisamos preparar o ambiente.

Requisitos

  • Múltiplos servidores em diferentes locais (físicos ou virtuais)
  • Oracle Linux 9 (ou outra distribuição Linux compatível)
  • Docker ou Kubernetes
  • Acesso para configuração de BGP (próprio ASN ou acordo com provedor)
  • Bloco de endereços IP para Anycast (preferencialmente /24 ou menor)

Configuração de Rede

Cada servidor precisa ter:

  1. Interface de gerenciamento: Para acesso administrativo (Unicast)
  2. Interface Anycast: Para tráfego DNS Anycast

Exemplo de configuração de rede:

1
2
3
4
5
6
7
8
9
10
11
12
13

+------------------+
| Servidor 1       |
|                  |
| eth0: 203.0.113.1|  <- Interface de gerenciamento (Unicast)
| lo:1: 192.0.2.53 |  <- Interface Anycast
+------------------+

+------------------+
| Servidor 2       |
|                  |
| eth0: 198.51.100.1| <- Interface de gerenciamento (Unicast)
| lo:1: 192.0.2.53 |  <- Interface Anycast (mesmo IP que Servidor 1)
+------------------+

Configuração do Sistema Operacional

Precisamos ajustar algumas configurações do sistema operacional:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# Habilitar encaminhamento de IP
echo "net.ipv4.ip_forward=1" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

# Configurar interface loopback para Anycast
sudo ip addr add 192.0.2.53/32 dev lo
sudo ip link set lo up

# Persistir configuração
cat > /etc/sysconfig/network-scripts/ifcfg-lo:1 << EOF
DEVICE=lo:1
IPADDR=192.0.2.53
NETMASK=255.255.255.255
ONBOOT=yes
EOF

Instalação do Bird

Vamos instalar o daemon Bird para BGP:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

# Instalar Bird
sudo dnf install -y bird

# Configuração básica do Bird
cat > /etc/bird/bird.conf << EOF
# Configuração básica do Bird para Anycast DNS
log syslog all;

# Configuração do roteador
router id 203.0.113.1;  # Use o IP unicast do servidor

# Filtros
filter export_anycast {
    if net = 192.0.2.53/32 then accept;
    reject;
}

# Protocolo de roteamento interno
protocol direct {
    interface "lo";  # Apenas interface loopback
}

# Protocolo BGP
protocol bgp peer1 {
    local as 64512;  # Seu ASN
    neighbor 203.0.113.254 as 65000;  # IP e ASN do roteador upstream
    
    export filter export_anycast;
    import none;
}
EOF

# Iniciar e habilitar Bird
sudo systemctl enable --now bird

Implementação de DNS Anycast com Docker

Vamos implementar o DNS Anycast usando Docker.

Imagem Docker para BIND Anycast

Vamos criar uma imagem Docker específica para BIND Anycast:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

# Dockerfile para BIND Anycast
FROM oraclelinux:9

# Instalar BIND e utilitários
RUN dnf -y install bind bind-utils bind-dnssec-utils && \
    dnf clean all && \
    mkdir -p /var/named/zones /var/named/data /var/named/dynamic /var/log/named && \
    chown -R named:named /var/named /var/log/named

# Copiar arquivos de configuração
COPY config/named.conf /etc/named.conf
COPY config/rndc.key /etc/rndc.key
COPY zones/ /var/named/zones/

# Configurar permissões
RUN chown root:named /etc/named.conf /etc/rndc.key && \
    chmod 640 /etc/named.conf /etc/rndc.key && \
    chown named:named /var/named/zones/* && \
    chmod 640 /var/named/zones/*

# Copiar scripts
COPY scripts/entrypoint.sh /entrypoint.sh
COPY scripts/healthcheck.sh /healthcheck.sh
RUN chmod +x /entrypoint.sh /healthcheck.sh

# Expor portas
EXPOSE 53/tcp 53/udp 953/tcp

# Configurar healthcheck
HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 CMD ["/healthcheck.sh"]

# Definir usuário
USER named

# Definir entrypoint
ENTRYPOINT ["/entrypoint.sh"]
CMD ["named", "-g", "-c", "/etc/named.conf"]

Configuração do BIND para Anycast

A configuração do BIND para Anycast é similar à configuração padrão, mas com algumas considerações específicas:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

// named.conf para Anycast
options {
    directory "/var/named";
    
    listen-on port 53 { 
        127.0.0.1;
        192.0.2.53;  // Endereço Anycast
    };
    listen-on-v6 port 53 { ::1; };
    
    allow-query { any; };
    recursion no;
    
    // Configurações de desempenho para Anycast
    tcp-clients 1000;
    tcp-listen-queue 128;
    
    // Configurações de segurança
    rate-limit {
        responses-per-second 20;
        window 5;
    };
    
    // Logging
    logging {
        channel general_log {
            file "/var/log/named/general.log" versions 3 size 5m;
            severity info;
            print-time yes;
            print-severity yes;
            print-category yes;
        };
        
        category default { general_log; };
    };
};

// Zone definitions
zone "example.com" IN {
    type master;
    file "zones/example.com.zone";
    allow-transfer { none; };
};

// Include standard zones
include "/etc/named.rfc1912.zones";

Execução do Container BIND Anycast

Para executar o container BIND Anycast, usamos o modo host de rede para acessar diretamente o endereço Anycast:

1
2
3
4
5
6
7
8

# Executar container BIND Anycast
docker run -d --name bind-anycast \
  --network host \
  --restart=unless-stopped \
  -v $(pwd)/config:/etc/bind \
  -v $(pwd)/zones:/var/named/zones \
  -v $(pwd)/logs:/var/log/named \
  bind-anycast:latest

Script de Verificação de Saúde

O script de verificação de saúde é crucial para o Anycast, pois determina se o servidor deve continuar anunciando o prefixo Anycast:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#!/bin/bash
# healthcheck.sh - Script para verificar a saúde do servidor BIND Anycast

# Verificar se o processo named está em execução
pgrep named > /dev/null
if [ $? -ne 0 ]; then
    echo "Processo named não está em execução."
    exit 1
fi

# Verificar se o servidor está respondendo a consultas no endereço Anycast
dig @192.0.2.53 example.com SOA +short > /dev/null
if [ $? -ne 0 ]; then
    echo "Servidor DNS não está respondendo a consultas no endereço Anycast."
    exit 1
fi

# Verificar latência das respostas
response_time=$(dig @192.0.2.53 example.com +stats | grep "Query time:" | awk '{print $4}')
if [ $response_time -gt 100 ]; then
    echo "Latência de resposta muito alta: $response_time ms."
    exit 1
fi

# Tudo OK
echo "Servidor DNS Anycast saudável."
exit 0

Integração com Bird

Para integrar o container BIND com o Bird, precisamos de um script que verifique a saúde do container e controle o anúncio BGP:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

#!/bin/bash
# anycast-control.sh - Controla anúncios BGP baseado na saúde do container BIND

# Verificar saúde do container
docker exec bind-anycast /healthcheck.sh
if [ $? -ne 0 ]; then
    # Container não está saudável, remover anúncio BGP
    echo "Container BIND não está saudável, removendo anúncio BGP..."
    
    # Remover rota Anycast
    ip route del 192.0.2.53/32
    
    # Reconfigurar Bird para parar de anunciar
    cat > /etc/bird/bird.conf << EOF
# Configuração do Bird sem anúncio Anycast
log syslog all;
router id 203.0.113.1;
protocol direct {
    interface "lo";
}
protocol bgp peer1 {
    local as 64512;
    neighbor 203.0.113.254 as 65000;
    export none;
    import none;
}
EOF
    
    # Recarregar Bird
    birdc configure
    
    exit 1
else
    # Container está saudável, verificar se anúncio BGP está ativo
    ip route show | grep 192.0.2.53/32 > /dev/null
    if [ $? -ne 0 ]; then
        # Anúncio não está ativo, ativar
        echo "Container BIND saudável, ativando anúncio BGP..."
        
        # Adicionar rota Anycast
        ip route add 192.0.2.53/32 dev lo
        
        # Reconfigurar Bird para anunciar
        cat > /etc/bird/bird.conf << EOF
# Configuração do Bird com anúncio Anycast
log syslog all;
router id 203.0.113.1;
filter export_anycast {
    if net = 192.0.2.53/32 then accept;
    reject;
}
protocol direct {
    interface "lo";
}
protocol bgp peer1 {
    local as 64512;
    neighbor 203.0.113.254 as 65000;
    export filter export_anycast;
    import none;
}
EOF
        
        # Recarregar Bird
        birdc configure
    fi
fi

exit 0

Configuração do Cron para Verificação Periódica

Configuramos o cron para executar o script de controle periodicamente:

1
2

# Adicionar ao crontab
echo "* * * * * /usr/local/bin/anycast-control.sh >> /var/log/anycast-control.log 2>&1" | sudo tee -a /etc/crontab

Implementação de DNS Anycast com Kubernetes

Para ambientes mais complexos, podemos implementar DNS Anycast com Kubernetes.

Arquitetura Kubernetes para DNS Anycast

Em um ambiente Kubernetes, a arquitetura será:

  1. Cluster Kubernetes em cada local
  2. DaemonSet BIND para garantir um pod em cada nó
  3. Sidecar BGP para anunciar o prefixo Anycast
  4. ConfigMaps para configuração do BIND e BGP
  5. Serviço NodePort para expor o DNS

Arquitetura Kubernetes para DNS Anycast

Em um ambiente Kubernetes, a arquitetura será:

  1. Cluster Kubernetes em cada local
  2. DaemonSet BIND para garantir um pod em cada nó
  3. Sidecar BGP para anunciar o prefixo Anycast
  4. ConfigMaps para configuração do BIND e BGP
  5. Serviço NodePort para expor o DNS
+--------------------------------------------------------------------------------------------------+
|                                        Cluster Kubernetes (Local A)                                |
+--------------------------------------------------------------------------------------------------+
| Nó 1                                     | Nó 2                                     | Nó 3         |
| +--------------------------------------+ | +--------------------------------------+ | +------------+ |
| | Pod BIND Anycast (DaemonSet)         | | Pod BIND Anycast (DaemonSet)         | | ...        | |
| | +----------------+ +---------------+ | | +----------------+ +---------------+ | |            | |
| | | Container BIND | | Container BGP | | | | Container BIND | | Container BGP | | |            | |
| | | (Escuta IP     | | (Anuncia IP   | | | | (Escuta IP     | | (Anuncia IP   | | |            | |
| | | Anycast)       | | Anycast)      | | | | Anycast)       | | Anycast)      | | |            | |
| | +----------------+ +---------------+ | | +----------------+ +---------------+ | |            | |
| +--------------------------------------+ | +--------------------------------------+ | +------------+ |
|        ^                                 |        ^                                 |              |
|        | Service NodePort (Porta 53)     |        | Service NodePort (Porta 53)     |              |
|        +---------------------------------+        +---------------------------------+              |
|                               |                                |                                |
| <-----------------------------+--------------------------------+---------------------------------> Rede Externa / Internet
|                                      (Tráfego DNS Anycast)
+--------------------------------------------------------------------------------------------------+

Figura 3: Arquitetura Kubernetes para DNS Anycast

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188

# kubernetes/bind-anycast.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: bind-config
data:
  named.conf: |
    // named.conf para Anycast em Kubernetes
    options {
        directory "/var/named";
        
        listen-on port 53 { 
            127.0.0.1;
            192.0.2.53;  // Endereço Anycast
        };
        listen-on-v6 port 53 { ::1; };
        
        allow-query { any; };
        recursion no;
        
        // Configurações de desempenho para Anycast
        tcp-clients 1000;
        tcp-listen-queue 128;
        
        // Logging
        logging {
            channel general_log {
                file "/var/log/named/general.log" versions 3 size 5m;
                severity info;
                print-time yes;
                print-severity yes;
                print-category yes;
            };
            
            category default { general_log; };
        };
    };

    // Zone definitions
    zone "example.com" IN {
        type master;
        file "zones/example.com.zone";
        allow-transfer { none; };
    };

    // Include standard zones
    include "/etc/named.rfc1912.zones";

---
apiVersion: v1
kind: ConfigMap
metadata:
  name: bind-zones
data:
  example.com.zone: |
    $TTL 86400
    @       IN SOA  ns1.example.com. admin.example.com. (
                        2025052601  ; Serial
                        10800       ; Refresh
                        3600        ; Retry
                        604800      ; Expire
                        86400 )     ; Minimum TTL

            IN NS   ns1.example.com.
            IN NS   ns2.example.com.

    ns1     IN A    192.0.2.53
    ns2     IN A    192.0.2.53
    www     IN A    203.0.113.10
    mail    IN A    203.0.113.20
    @       IN MX   10 mail.example.com.

---
apiVersion: v1
kind: ConfigMap
metadata:
  name: bird-config
data:
  bird.conf: |
    # Configuração do Bird para Anycast em Kubernetes
    log syslog all;
    router id 203.0.113.1;
    
    filter export_anycast {
        if net = 192.0.2.53/32 then accept;
        reject;
    }
    
    protocol direct {
        interface "lo";
    }
    
    protocol bgp peer1 {
        local as 64512;
        neighbor 203.0.113.254 as 65000;
        export filter export_anycast;
        import none;
    }

---
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: bind-anycast
  labels:
    app: bind-anycast
spec:
  selector:
    matchLabels:
      app: bind-anycast
  template:
    metadata:
      labels:
        app: bind-anycast
    spec:
      hostNetwork: true
      containers:
      - name: bind
        image: bind-anycast:latest
        securityContext:
          capabilities:
            add: ["NET_ADMIN"]
        ports:
        - containerPort: 53
          protocol: TCP
          name: dns-tcp
        - containerPort: 53
          protocol: UDP
          name: dns-udp
        volumeMounts:
        - name: config
          mountPath: /etc/named.conf
          subPath: named.conf
        - name: zones
          mountPath: /var/named/zones
        - name: logs
          mountPath: /var/log/named
        livenessProbe:
          exec:
            command:
            - /healthcheck.sh
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          exec:
            command:
            - dig
            - @127.0.0.1
            - example.com
            - SOA
            - +short
          initialDelaySeconds: 5
          periodSeconds: 10
      
      - name: bird
        image: osrg/bird:latest
        securityContext:
          privileged: true
        volumeMounts:
        - name: bird-config
          mountPath: /etc/bird/bird.conf
          subPath: bird.conf
        - name: host-run
          mountPath: /host/run
        livenessProbe:
          exec:
            command:
            - birdc
            - show
            - status
          initialDelaySeconds: 30
          periodSeconds: 10
      
      volumes:
      - name: config
        configMap:
          name: bind-config
      - name: zones
        configMap:
          name: bind-zones
      - name: bird-config
        configMap:
          name: bird-config
      - name: logs
        emptyDir: {}
      - name: host-run
        hostPath:
          path: /run

Inicialização do Endereço Anycast

Para inicializar o endereço Anycast em cada nó Kubernetes, precisamos de um Job de inicialização:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

# kubernetes/anycast-init.yaml
apiVersion: batch/v1
kind: Job
metadata:
  name: anycast-init
spec:
  template:
    spec:
      hostNetwork: true
      containers:
      - name: anycast-init
        image: oraclelinux:9
        command:
        - /bin/bash
        - -c
        - |
          # Adicionar endereço Anycast à interface loopback
          ip addr add 192.0.2.53/32 dev lo
          ip link set lo up
          
          # Verificar se o endereço foi adicionado
          ip addr show lo | grep 192.0.2.53
          if [ $? -eq 0 ]; then
            echo "Endereço Anycast configurado com sucesso."
            exit 0
          else
            echo "Falha ao configurar endereço Anycast."
            exit 1
          fi
        securityContext:
          privileged: true
      restartPolicy: OnFailure

Integração com MetalLB para Kubernetes

Para ambientes Kubernetes onde não é possível usar o modo hostNetwork, podemos usar o MetalLB para anunciar o endereço Anycast:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# kubernetes/metallb-config.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  namespace: metallb-system
  name: config
data:
  config: |
    address-pools:
    - name: anycast-pool
      protocol: bgp
      addresses:
      - 192.0.2.53/32
      
    peers:
    - peer-address: 203.0.113.254
      peer-asn: 65000
      my-asn: 64512

Automação de DNS Anycast com Ansible

Vamos automatizar a implantação de DNS Anycast com Ansible.

Role Ansible para DNS Anycast

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

# ansible/roles/bind_anycast/tasks/main.yml
---
- name: Instalar dependências
  dnf:
    name:
      - docker
      - bird
      - bind-utils
    state: present

- name: Configurar interface loopback para Anycast
  command: ip addr add {{ anycast_ip }}/32 dev lo
  ignore_errors: yes

- name: Persistir configuração de loopback
  template:
    src: ifcfg-lo-anycast.j2
    dest: /etc/sysconfig/network-scripts/ifcfg-lo:1
    owner: root
    group: root
    mode: '0644'

- name: Configurar Bird para BGP
  template:
    src: bird.conf.j2
    dest: /etc/bird/bird.conf
    owner: root
    group: root
    mode: '0644'
  notify: Restart Bird

- name: Iniciar e habilitar Bird
  systemd:
    name: bird
    state: started
    enabled: yes

- name: Criar diretórios para BIND
  file:
    path: "{{ item }}"
    state: directory
    owner: root
    group: root
    mode: '0755'
  loop:
    - "{{ bind_config_dir }}"
    - "{{ bind_zones_dir }}"
    - "{{ bind_logs_dir }}"

- name: Copiar configuração do BIND
  template:
    src: named.conf.j2
    dest: "{{ bind_config_dir }}/named.conf"
    owner: root
    group: root
    mode: '0644'

- name: Copiar arquivos de zona
  template:
    src: "zones/{{ item }}.zone.j2"
    dest: "{{ bind_zones_dir }}/{{ item }}.zone"
    owner: root
    group: root
    mode: '0644'
  loop: "{{ bind_zones }}"

- name: Copiar scripts de controle Anycast
  template:
    src: "{{ item.src }}"
    dest: "/usr/local/bin/{{ item.dest }}"
    owner: root
    group: root
    mode: '0755'
  loop:
    - { src: 'anycast-control.sh.j2', dest: 'anycast-control.sh' }
    - { src: 'healthcheck.sh.j2', dest: 'healthcheck.sh' }

- name: Configurar cron para verificação periódica
  cron:
    name: "Verificar saúde do DNS Anycast"
    job: "/usr/local/bin/anycast-control.sh >> /var/log/anycast-control.log 2>&1"
    minute: "*"
    state: present

- name: Construir imagem Docker para BIND Anycast
  docker_image:
    name: bind-anycast
    build:
      path: "{{ bind_docker_build_dir }}"
      pull: yes
    source: build
    state: present

- name: Executar container BIND Anycast
  docker_container:
    name: bind-anycast
    image: bind-anycast:latest
    network_mode: host
    restart_policy: unless-stopped
    volumes:
      - "{{ bind_config_dir }}/named.conf:/etc/named.conf:ro"
      - "{{ bind_zones_dir }}:/var/named/zones:ro"
      - "{{ bind_logs_dir }}:/var/log/named:rw"

Templates Ansible

Template para Bird

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# ansible/roles/bind_anycast/templates/bird.conf.j2
# Configuração do Bird para Anycast DNS
log syslog all;

# Configuração do roteador
router id {{ ansible_default_ipv4.address }};

# Filtros
filter export_anycast {
    if net = {{ anycast_ip }}/32 then accept;
    reject;
}

# Protocolo de roteamento interno
protocol direct {
    interface "lo";  # Apenas interface loopback
}

# Protocolo BGP
protocol bgp peer1 {
    local as {{ local_asn }};
    neighbor {{ upstream_router }} as {{ upstream_asn }};
    
    export filter export_anycast;
    import none;
}

Template para Interface Loopback

1
2
3
4
5

# ansible/roles/bind_anycast/templates/ifcfg-lo-anycast.j2
DEVICE=lo:1
IPADDR={{ anycast_ip }}
NETMASK=255.255.255.255
ONBOOT=yes

Template para Script de Controle Anycast

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

# ansible/roles/bind_anycast/templates/anycast-control.sh.j2
#!/bin/bash
# anycast-control.sh - Controla anúncios BGP baseado na saúde do container BIND

# Verificar saúde do container
docker exec bind-anycast /healthcheck.sh
if [ $? -ne 0 ]; then
    # Container não está saudável, remover anúncio BGP
    echo "Container BIND não está saudável, removendo anúncio BGP..."
    
    # Remover rota Anycast
    ip route del {{ anycast_ip }}/32
    
    # Reconfigurar Bird para parar de anunciar
    cat > /etc/bird/bird.conf << EOF
# Configuração do Bird sem anúncio Anycast
log syslog all;
router id {{ ansible_default_ipv4.address }};
protocol direct {
    interface "lo";
}
protocol bgp peer1 {
    local as {{ local_asn }};
    neighbor {{ upstream_router }} as {{ upstream_asn }};
    export none;
    import none;
}
EOF
    
    # Recarregar Bird
    birdc configure
    
    exit 1
else
    # Container está saudável, verificar se anúncio BGP está ativo
    ip route show | grep {{ anycast_ip }}/32 > /dev/null
    if [ $? -ne 0 ]; then
        # Anúncio não está ativo, ativar
        echo "Container BIND saudável, ativando anúncio BGP..."
        
        # Adicionar rota Anycast
        ip route add {{ anycast_ip }}/32 dev lo
        
        # Reconfigurar Bird para anunciar
        cat > /etc/bird/bird.conf << EOF
# Configuração do Bird com anúncio Anycast
log syslog all;
router id {{ ansible_default_ipv4.address }};
filter export_anycast {
    if net = {{ anycast_ip }}/32 then accept;
    reject;
}
protocol direct {
    interface "lo";
}
protocol bgp peer1 {
    local as {{ local_asn }};
    neighbor {{ upstream_router }} as {{ upstream_asn }};
    export filter export_anycast;
    import none;
}
EOF
        
        # Recarregar Bird
        birdc configure
    fi
fi

exit 0

Playbook Ansible para DNS Anycast

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# ansible/playbooks/anycast.yml
---
- name: Configurar servidores DNS Anycast
  hosts: anycast_servers
  become: yes
  vars:
    anycast_ip: "192.0.2.53"
    local_asn: "64512"
    upstream_router: "{{ ansible_default_ipv4.gateway }}"
    upstream_asn: "65000"
    
    bind_config_dir: "/etc/bind"
    bind_zones_dir: "/var/named/zones"
    bind_logs_dir: "/var/log/named"
    bind_docker_build_dir: "/opt/bind-anycast"
    
    bind_zones:
      - "example.com"
      - "200.168.192.in-addr.arpa"
  
  roles:
    - bind_anycast

Integração com GitLab CI/CD

Vamos integrar nossa implementação de DNS Anycast com GitLab CI/CD.

Pipeline GitLab CI/CD para DNS Anycast

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

# .gitlab-ci.yml
---
stages:
  - validate
  - build
  - test
  - deploy_dev
  - deploy_prod

variables:
  ANSIBLE_CONFIG: ansible/ansible.cfg
  DOCKER_IMAGE_NAME: bind-anycast
  DOCKER_REGISTRY: registry.example.com

# Validação de sintaxe e lint
validate:
  stage: validate
  image: python:3.9-slim
  before_script:
    - apt-get update && apt-get install -y bind9utils
    - pip install ansible ansible-lint
  script:
    - ansible-playbook ansible/playbooks/anycast.yml --syntax-check
    - ansible-lint ansible/playbooks/anycast.yml
  tags:
    - docker

# Construção da imagem Docker
build_docker:
  stage: build
  image: docker:20.10
  services:
    - docker:20.10-dind
  variables:
    DOCKER_TLS_CERTDIR: "/certs"
  before_script:
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
  script:
    - docker build -t $DOCKER_REGISTRY/$DOCKER_IMAGE_NAME:$CI_COMMIT_SHORT_SHA -t $DOCKER_REGISTRY/$DOCKER_IMAGE_NAME:latest docker/bind-anycast/
    - docker push $DOCKER_REGISTRY/$DOCKER_IMAGE_NAME:$CI_COMMIT_SHORT_SHA
    - docker push $DOCKER_REGISTRY/$DOCKER_IMAGE_NAME:latest
  only:
    - master
    - development
  tags:
    - docker

# Testes em ambiente de desenvolvimento
test_dev:
  stage: test
  before_script:
    - 'which ssh-agent || ( apt-get update -y && apt-get install openssh-client -y )'
    - eval $(ssh-agent -s)
    - echo "$SSH_PRIVATE_KEY" | tr -d '\r' | ssh-add -
    - mkdir -p ~/.ssh
    - chmod 700 ~/.ssh
    - echo -e "Host *\n\tStrictHostKeyChecking no\n\n" > ~/.ssh/config
  script:
    - ansible-playbook -i ansible/inventory/development/hosts.yml ansible/playbooks/anycast.yml --check -e "docker_image_tag=$CI_COMMIT_SHORT_SHA"
  environment:
    name: development
  tags:
    - shell
  only:
    - master
    - development

# Implantação em ambiente de desenvolvimento
deploy_dev:
  stage: deploy_dev
  before_script:
    - 'which ssh-agent || ( apt-get update -y && apt-get install openssh-client -y )'
    - eval $(ssh-agent -s)
    - echo "$SSH_PRIVATE_KEY" | tr -d '\r' | ssh-add -
    - mkdir -p ~/.ssh
    - chmod 700 ~/.ssh
    - echo -e "Host *\n\tStrictHostKeyChecking no\n\n" > ~/.ssh/config
  script:
    - ansible-playbook -i ansible/inventory/development/hosts.yml ansible/playbooks/anycast.yml -e "docker_image_tag=$CI_COMMIT_SHORT_SHA"
  environment:
    name: development
  tags:
    - shell
  only:
    - master
    - development

# Implantação em ambiente de produção
deploy_prod:
  stage: deploy_prod
  before_script:
    - 'which ssh-agent || ( apt-get update -y && apt-get install openssh-client -y )'
    - eval $(ssh-agent -s)
    - echo "$SSH_PRIVATE_KEY" | tr -d '\r' | ssh-add -
    - mkdir -p ~/.ssh
    - chmod 700 ~/.ssh
    - echo -e "Host *\n\tStrictHostKeyChecking no\n\n" > ~/.ssh/config
  script:
    - ansible-playbook -i ansible/inventory/production/hosts.yml ansible/playbooks/anycast.yml -e "docker_image_tag=$CI_COMMIT_SHORT_SHA"
  environment:
    name: production
  when: manual
  tags:
    - shell
  only:
    - master

Monitoramento de DNS Anycast

O monitoramento é crucial para uma infraestrutura DNS Anycast.

Monitoramento com Prometheus e Grafana

Configuração do Prometheus

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

# prometheus/prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'bind_anycast'
    static_configs:
      - targets: ['anycast-server-1:9119', 'anycast-server-2:9119']
        labels:
          service: 'bind-anycast'
  
  - job_name: 'bird_exporter'
    static_configs:
      - targets: ['anycast-server-1:9324', 'anycast-server-2:9324']
        labels:
          service: 'bird-bgp'
  
  - job_name: 'blackbox_exporter'
    metrics_path: /probe
    params:
      module: [dns_anycast]
    static_configs:
      - targets:
        - 192.0.2.53  # Endereço Anycast
    relabel_configs:
      - source_labels: [__address__]
        target_label: __param_target
      - source_labels: [__param_target]
        target_label: instance
      - target_label: __address__
        replacement: blackbox-exporter:9115

Configuração do Blackbox Exporter

1
2
3
4
5
6
7
8
9
10
11
12

# blackbox/blackbox.yml
modules:
  dns_anycast:
    prober: dns
    dns:
      query_name: "example.com"
      query_type: "A"
      valid_rcodes:
        - NOERROR
      validate_answer_rrs:
        fail_if_not_matches_regexp:
          - "example.com.\\s+\\d+\\s+IN\\s+A\\s+203.0.113.10"

Dashboard Grafana para DNS Anycast

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418

{
  "annotations": {
    "list": [
      {
        "builtIn": 1,
        "datasource": "-- Grafana --",
        "enable": true,
        "hide": true,
        "iconColor": "rgba(0, 211, 255, 1)",
        "name": "Annotations & Alerts",
        "type": "dashboard"
      }
    ]
  },
  "editable": true,
  "gnetId": null,
  "graphTooltip": 0,
  "id": 1,
  "links": [],
  "panels": [
    {
      "aliasColors": {},
      "bars": false,
      "dashLength": 10,
      "dashes": false,
      "datasource": null,
      "fieldConfig": {
        "defaults": {
          "custom": {}
        },
        "overrides": []
      },
      "fill": 1,
      "fillGradient": 0,
      "gridPos": {
        "h": 8,
        "w": 12,
        "x": 0,
        "y": 0
      },
      "hiddenSeries": false,
      "id": 2,
      "legend": {
        "avg": false,
        "current": false,
        "max": false,
        "min": false,
        "show": true,
        "total": false,
        "values": false
      },
      "lines": true,
      "linewidth": 1,
      "nullPointMode": "null",
      "options": {
        "alertThreshold": true
      },
      "percentage": false,
      "pluginVersion": "7.3.7",
      "pointradius": 2,
      "points": false,
      "renderer": "flot",
      "seriesOverrides": [],
      "spaceLength": 10,
      "stack": false,
      "steppedLine": false,
      "targets": [
        {
          "expr": "probe_dns_lookup_time_seconds{instance=\"192.0.2.53\"}",
          "interval": "",
          "legendFormat": "DNS Lookup Time",
          "refId": "A"
        }
      ],
      "thresholds": [],
      "timeFrom": null,
      "timeRegions": [],
      "timeShift": null,
      "title": "DNS Lookup Time",
      "tooltip": {
        "shared": true,
        "sort": 0,
        "value_type": "individual"
      },
      "type": "graph",
      "xaxis": {
        "buckets": null,
        "mode": "time",
        "name": null,
        "show": true,
        "values": []
      },
      "yaxes": [
        {
          "format": "s",
          "label": null,
          "logBase": 1,
          "max": null,
          "min": null,
          "show": true
        },
        {
          "format": "short",
          "label": null,
          "logBase": 1,
          "max": null,
          "min": null,
          "show": true
        }
      ],
      "yaxis": {
        "align": false,
        "alignLevel": null
      }
    },
    {
      "aliasColors": {},
      "bars": false,
      "dashLength": 10,
      "dashes": false,
      "datasource": null,
      "fieldConfig": {
        "defaults": {
          "custom": {}
        },
        "overrides": []
      },
      "fill": 1,
      "fillGradient": 0,
      "gridPos": {
        "h": 8,
        "w": 12,
        "x": 12,
        "y": 0
      },
      "hiddenSeries": false,
      "id": 4,
      "legend": {
        "avg": false,
        "current": false,
        "max": false,
        "min": false,
        "show": true,
        "total": false,
        "values": false
      },
      "lines": true,
      "linewidth": 1,
      "nullPointMode": "null",
      "options": {
        "alertThreshold": true
      },
      "percentage": false,
      "pluginVersion": "7.3.7",
      "pointradius": 2,
      "points": false,
      "renderer": "flot",
      "seriesOverrides": [],
      "spaceLength": 10,
      "stack": false,
      "steppedLine": false,
      "targets": [
        {
          "expr": "probe_success{instance=\"192.0.2.53\"}",
          "interval": "",
          "legendFormat": "DNS Probe Success",
          "refId": "A"
        }
      ],
      "thresholds": [],
      "timeFrom": null,
      "timeRegions": [],
      "timeShift": null,
      "title": "DNS Availability",
      "tooltip": {
        "shared": true,
        "sort": 0,
        "value_type": "individual"
      },
      "type": "graph",
      "xaxis": {
        "buckets": null,
        "mode": "time",
        "name": null,
        "show": true,
        "values": []
      },
      "yaxes": [
        {
          "format": "short",
          "label": null,
          "logBase": 1,
          "max": "1",
          "min": "0",
          "show": true
        },
        {
          "format": "short",
          "label": null,
          "logBase": 1,
          "max": null,
          "min": null,
          "show": true
        }
      ],
      "yaxis": {
        "align": false,
        "alignLevel": null
      }
    },
    {
      "aliasColors": {},
      "bars": false,
      "dashLength": 10,
      "dashes": false,
      "datasource": null,
      "fieldConfig": {
        "defaults": {
          "custom": {}
        },
        "overrides": []
      },
      "fill": 1,
      "fillGradient": 0,
      "gridPos": {
        "h": 8,
        "w": 12,
        "x": 0,
        "y": 8
      },
      "hiddenSeries": false,
      "id": 6,
      "legend": {
        "avg": false,
        "current": false,
        "max": false,
        "min": false,
        "show": true,
        "total": false,
        "values": false
      },
      "lines": true,
      "linewidth": 1,
      "nullPointMode": "null",
      "options": {
        "alertThreshold": true
      },
      "percentage": false,
      "pluginVersion": "7.3.7",
      "pointradius": 2,
      "points": false,
      "renderer": "flot",
      "seriesOverrides": [],
      "spaceLength": 10,
      "stack": false,
      "steppedLine": false,
      "targets": [
        {
          "expr": "bind_incoming_queries_total{instance=~\"anycast-server-.*:9119\"}",
          "interval": "",
          "legendFormat": "{{instance}} - {{type}}",
          "refId": "A"
        }
      ],
      "thresholds": [],
      "timeFrom": null,
      "timeRegions": [],
      "timeShift": null,
      "title": "DNS Queries por Servidor",
      "tooltip": {
        "shared": true,
        "sort": 0,
        "value_type": "individual"
      },
      "type": "graph",
      "xaxis": {
        "buckets": null,
        "mode": "time",
        "name": null,
        "show": true,
        "values": []
      },
      "yaxes": [
        {
          "format": "short",
          "label": null,
          "logBase": 1,
          "max": null,
          "min": null,
          "show": true
        },
        {
          "format": "short",
          "label": null,
          "logBase": 1,
          "max": null,
          "min": null,
          "show": true
        }
      ],
      "yaxis": {
        "align": false,
        "alignLevel": null
      }
    },
    {
      "aliasColors": {},
      "bars": false,
      "dashLength": 10,
      "dashes": false,
      "datasource": null,
      "fieldConfig": {
        "defaults": {
          "custom": {}
        },
        "overrides": []
      },
      "fill": 1,
      "fillGradient": 0,
      "gridPos": {
        "h": 8,
        "w": 12,
        "x": 12,
        "y": 8
      },
      "hiddenSeries": false,
      "id": 8,
      "legend": {
        "avg": false,
        "current": false,
        "max": false,
        "min": false,
        "show": true,
        "total": false,
        "values": false
      },
      "lines": true,
      "linewidth": 1,
      "nullPointMode": "null",
      "options": {
        "alertThreshold": true
      },
      "percentage": false,
      "pluginVersion": "7.3.7",
      "pointradius": 2,
      "points": false,
      "renderer": "flot",
      "seriesOverrides": [],
      "spaceLength": 10,
      "stack": false,
      "steppedLine": false,
      "targets": [
        {
          "expr": "bird_protocol_up{instance=~\"anycast-server-.*:9324\", proto=\"peer1\"}",
          "interval": "",
          "legendFormat": "{{instance}} - BGP Status",
          "refId": "A"
        }
      ],
      "thresholds": [],
      "timeFrom": null,
      "timeRegions": [],
      "timeShift": null,
      "title": "BGP Status",
      "tooltip": {
        "shared": true,
        "sort": 0,
        "value_type": "individual"
      },
      "type": "graph",
      "xaxis": {
        "buckets": null,
        "mode": "time",
        "name": null,
        "show": true,
        "values": []
      },
      "yaxes": [
        {
          "format": "short",
          "label": null,
          "logBase": 1,
          "max": "1",
          "min": "0",
          "show": true
        },
        {
          "format": "short",
          "label": null,
          "logBase": 1,
          "max": null,
          "min": null,
          "show": true
        }
      ],
      "yaxis": {
        "align": false,
        "alignLevel": null
      }
    }
  ],
  "refresh": "5s",
  "schemaVersion": 26,
  "style": "dark",
  "tags": [],
  "templating": {
    "list": []
  },
  "time": {
    "from": "now-1h",
    "to": "now"
  },
  "timepicker": {},
  "timezone": "",
  "title": "DNS Anycast Dashboard",
  "uid": "dns_anycast",
  "version": 1
}

Alertas para DNS Anycast

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

# prometheus/alerts.yml
groups:
- name: dns_anycast_alerts
  rules:
  - alert: DNSAnycastDown
    expr: probe_success{instance="192.0.2.53"} == 0
    for: 5m
    labels:
      severity: critical
    annotations:
      summary: "DNS Anycast service is down"
      description: "DNS Anycast service at 192.0.2.53 has been down for more than 5 minutes."
  
  - alert: DNSAnycastHighLatency
    expr: probe_dns_lookup_time_seconds{instance="192.0.2.53"} > 0.1
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "DNS Anycast high latency"
      description: "DNS Anycast service at 192.0.2.53 has high latency (> 100ms) for more than 5 minutes."
  
  - alert: BGPSessionDown
    expr: bird_protocol_up{proto="peer1"} == 0
    for: 5m
    labels:
      severity: critical
    annotations:
      summary: "BGP session down"
      description: "BGP session on {{ $labels.instance }} is down for more than 5 minutes."
  
  - alert: AnycastNodeDown
    expr: up{job="bind_anycast"} == 0
    for: 5m
    labels:
      severity: critical
    annotations:
      summary: "Anycast node down"
      description: "Anycast node {{ $labels.instance }} is down for more than 5 minutes."

Testes e Validação de DNS Anycast

Para garantir que nossa implementação de DNS Anycast está funcionando corretamente, precisamos realizar testes e validação.

Testes de Funcionalidade

1
2
3
4
5
6
7
8
9
10
11

# Verificar se o servidor responde a consultas
dig @192.0.2.53 example.com

# Verificar latência
dig @192.0.2.53 example.com +stats

# Verificar se o servidor responde a consultas TCP
dig @192.0.2.53 example.com +tcp

# Verificar se o servidor responde a consultas IPv6 (se configurado)
dig @2001:db8::53 example.com

Testes de Roteamento

1
2
3
4
5
6

# Verificar rota para o endereço Anycast
traceroute 192.0.2.53

# Verificar anúncios BGP
birdc show route
birdc show protocols

Testes de Failover

Para testar o failover, podemos simular uma falha em um dos servidores:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# Parar o container BIND em um servidor
docker stop bind-anycast

# Verificar se o Bird parou de anunciar o prefixo
birdc show route
ip route show | grep 192.0.2.53

# Verificar se as consultas ainda são respondidas (por outro servidor)
dig @192.0.2.53 example.com

# Reiniciar o container
docker start bind-anycast

# Verificar se o Bird voltou a anunciar o prefixo
birdc show route
ip route show | grep 192.0.2.53

Testes de Carga

Para testar o desempenho sob carga, podemos usar ferramentas como dnsperf:

1
2
3
4
5
6
7
8
9
10
11
12

# Instalar dnsperf
sudo dnf install dnsperf

# Criar arquivo de consultas
cat > queries.txt << EOF
example.com A
www.example.com A
mail.example.com A
EOF

# Executar teste de carga
dnsperf -s 192.0.2.53 -d queries.txt -c 10 -l 30

Melhores Práticas para DNS Anycast com Containers

Segurança

  1. Isolamento de rede: Use redes dedicadas para tráfego Anycast
  2. Filtragem de pacotes: Implemente regras de firewall para permitir apenas tráfego DNS legítimo
  3. TSIG para transferências: Use TSIG para proteger transferências de zona
  4. DNSSEC: Implemente DNSSEC para autenticar respostas DNS
  5. Rate limiting: Configure rate limiting para mitigar ataques DDoS
  6. Monitoramento de segurança: Implemente monitoramento e alertas para atividades suspeitas

Desempenho

  1. Dimensionamento adequado: Garanta que cada nó tenha recursos suficientes
  2. Otimização de cache: Configure o cache do BIND para o tamanho apropriado
  3. Tuning de rede: Otimize parâmetros de rede para tráfego UDP e TCP
  4. Distribuição geográfica: Distribua servidores estrategicamente para minimizar latência
  5. Monitoramento de desempenho: Monitore métricas de desempenho e estabeleça baselines

Alta Disponibilidade

  1. Múltiplos nós: Implante servidores em múltiplos locais
  2. Diversidade de provedores: Use diferentes provedores de rede
  3. Verificações de saúde: Implemente verificações de saúde robustas
  4. Automação de failover: Automatize o processo de failover
  5. Testes regulares: Realize testes de failover regularmente

Operações

  1. Automação: Automatize implantação, configuração e atualizações
  2. Monitoramento centralizado: Implemente monitoramento centralizado
  3. Documentação: Mantenha documentação detalhada da infraestrutura
  4. Backups: Implemente backups regulares de configuração
  5. Atualizações sem downtime: Implemente estratégias para atualizações sem interrupção

Troubleshooting de DNS Anycast

Problemas Comuns e Soluções

Problema: Servidor não anuncia prefixo Anycast

Sintomas:

  • O endereço Anycast não aparece nas tabelas de roteamento
  • Bird não mostra o prefixo nos anúncios

Verificações:

1
2
3
4
5
6
7
8
9
10

# Verificar se o endereço está configurado na interface loopback
ip addr show lo | grep 192.0.2.53

# Verificar configuração do Bird
cat /etc/bird/bird.conf

# Verificar status do Bird
birdc show status
birdc show protocols
birdc show route

Possíveis Causas e Soluções:

  1. Endereço não configurado: Adicionar o endereço à interface loopback
  2. Configuração incorreta do Bird: Verificar e corrigir a configuração
  3. Bird não está em execução: Iniciar o serviço Bird
  4. Filtros BGP incorretos: Verificar e corrigir os filtros de exportação

Problema: Consultas DNS não são respondidas

Sintomas:

  • Consultas para o endereço Anycast resultam em timeout
  • O servidor não responde a consultas DNS

Verificações:

1
2
3
4
5
6
7
8
9
10
11

# Verificar se o container BIND está em execução
docker ps | grep bind-anycast

# Verificar logs do container
docker logs bind-anycast

# Verificar se o BIND está escutando no endereço Anycast
docker exec bind-anycast netstat -tulpn | grep 53

# Verificar configuração do BIND
docker exec bind-anycast cat /etc/named.conf

Possíveis Causas e Soluções:

  1. Container não está em execução: Iniciar o container
  2. BIND não está escutando no endereço Anycast: Verificar a configuração listen-on
  3. Firewall bloqueando tráfego: Verificar regras de firewall
  4. Configuração incorreta do BIND: Verificar e corrigir a configuração

Problema: Latência alta

Sintomas:

  • Consultas DNS têm latência alta
  • Clientes são roteados para servidores distantes

Verificações:

1
2
3
4
5
6
7
8

# Verificar latência das consultas
dig @192.0.2.53 example.com +stats

# Verificar rota para o endereço Anycast
traceroute 192.0.2.53

# Verificar anúncios BGP
birdc show route

Possíveis Causas e Soluções:

  1. Roteamento subótimo: Verificar configuração BGP e políticas de roteamento
  2. Servidor sobrecarregado: Verificar utilização de recursos e escalar se necessário
  3. Problemas de rede: Verificar conectividade e congestionamento de rede

Script de Diagnóstico

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

#!/bin/bash
# anycast-diagnose.sh - Script para diagnóstico de problemas com DNS Anycast

echo "=== Diagnóstico de DNS Anycast ==="
echo

echo "=== Verificando configuração de rede ==="
ip addr show lo | grep 192.0.2.53
ip route show | grep 192.0.2.53
echo

echo "=== Verificando status do Bird ==="
systemctl status bird
birdc show status
birdc show protocols
birdc show route
echo

echo "=== Verificando status do container BIND ==="
docker ps | grep bind-anycast
docker exec bind-anycast netstat -tulpn | grep 53
echo

echo "=== Verificando logs do container BIND ==="
docker logs --tail 20 bind-anycast
echo

echo "=== Testando consultas DNS ==="
dig @127.0.0.1 example.com +short
dig @192.0.2.53 example.com +short
echo

echo "=== Verificando latência das consultas ==="
dig @192.0.2.53 example.com +stats | grep "Query time"
echo

echo "=== Verificando conectividade com outros servidores Anycast ==="
# Substitua pelos IPs reais dos outros servidores
ping -c 3 203.0.113.1
ping -c 3 198.51.100.1
echo

echo "=== Diagnóstico concluído ==="

Casos de Uso Avançados

DNS Anycast com DNSSEC

Para implementar DNS Anycast com DNSSEC, precisamos garantir que todos os servidores tenham as mesmas chaves DNSSEC:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# Gerar chaves DNSSEC
dnssec-keygen -a ECDSAP256SHA256 -b 256 -n ZONE example.com
dnssec-keygen -a ECDSAP256SHA256 -b 256 -f KSK -n ZONE example.com

# Distribuir chaves para todos os servidores
ansible anycast_servers -m copy -a "src=/path/to/keys/ dest=/var/named/keys/"

# Configurar BIND para usar DNSSEC
cat > /etc/bind/named.conf << EOF
options {
    // ... outras opções ...
    
    dnssec-enable yes;
    dnssec-validation auto;
};

zone "example.com" IN {
    type master;
    file "zones/example.com.signed";
    key-directory "/var/named/keys";
    auto-dnssec maintain;
    inline-signing yes;
};
EOF

# Assinar zona
dnssec-signzone -A -3 $(head -c 16 /dev/random | od -v -t x | head -1 | cut -d' ' -f2- | tr -d ' ') -N INCREMENT -o example.com -t /var/named/zones/example.com.zone

DNS Anycast com Múltiplos Provedores

Para implementar DNS Anycast com múltiplos provedores, precisamos configurar BGP para cada provedor:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# Configuração do Bird com múltiplos provedores
log syslog all;
router id 203.0.113.1;

filter export_anycast {
    if net = 192.0.2.53/32 then accept;
    reject;
}

protocol direct {
    interface "lo";
}

# Provedor 1
protocol bgp provider1 {
    local as 64512;
    neighbor 203.0.113.254 as 65000;
    export filter export_anycast;
    import none;
}

# Provedor 2
protocol bgp provider2 {
    local as 64512;
    neighbor 203.0.113.253 as 65001;
    export filter export_anycast;
    import none;
}

DNS Anycast com Balanceamento de Carga

Para implementar DNS Anycast com balanceamento de carga, podemos usar o BGP para influenciar o roteamento:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

# Configuração do Bird com balanceamento de carga
log syslog all;
router id 203.0.113.1;

filter export_anycast_primary {
    if net = 192.0.2.53/32 then {
        bgp_community.add((65000, 100));  # Comunidade para preferência alta
        accept;
    }
    reject;
}

filter export_anycast_secondary {
    if net = 192.0.2.53/32 then {
        bgp_community.add((65000, 200));  # Comunidade para preferência baixa
        accept;
    }
    reject;
}

protocol direct {
    interface "lo";
}

# Configuração para servidor primário
protocol bgp provider1_primary {
    local as 64512;
    neighbor 203.0.113.254 as 65000;
    export filter export_anycast_primary;
    import none;
}

# Configuração para servidor secundário
protocol bgp provider1_secondary {
    local as 64512;
    neighbor 203.0.113.254 as 65000;
    export filter export_anycast_secondary;
    import none;
}

Conclusão

Neste tutorial, exploramos como implementar DNS Anycast em ambientes containerizados, combinando as vantagens do Anycast (baixa latência, alta disponibilidade, distribuição de carga) com a flexibilidade e portabilidade dos containers.

Abordamos desde os conceitos fundamentais do DNS Anycast até a implementação prática com Docker e Kubernetes, incluindo configuração de roteamento BGP, automação com Ansible e GitLab CI/CD, monitoramento com Prometheus e Grafana, e troubleshooting.

A combinação de DNS Anycast com containers oferece uma solução poderosa para organizações que precisam de uma infraestrutura DNS distribuída, resiliente e de baixa latência. Ao seguir as melhores práticas e implementar as técnicas descritas neste tutorial, você estará preparado para criar e gerenciar uma infraestrutura DNS Anycast moderna e eficiente.

Referências e Recursos Adicionais

Servidores, DNS, DevOps, Anycast
BIND DNS Oracle Linux Anycast Containers Docker Kubernetes BGP
This post is licensed under CC BY 4.0 by the author.