Post

Delegação e Subdomínios no DNS BIND

Posted
By Gean Martins
27 min read
Delegação e Subdomínios no DNS BIND

Este é o oitavo e último artigo de nossa série sobre implementação e configuração do DNS BIND no Oracle Linux 9. Nos artigos anteriores, abordamos os conceitos fundamentais do DNS, a instalação e configuração básica, a configuração de zonas DNS, a implementação de views e DNS Split-Horizon, a segurança e hardening, o logging, monitoramento e troubleshooting e as configurações avançadas. Agora, vamos explorar a delegação e gerenciamento de subdomínios.

Introdução

A delegação de subdomínios é um aspecto fundamental da arquitetura DNS, permitindo a descentralização da administração e a criação de uma estrutura hierárquica que reflete a organização de uma empresa ou instituição. Através da delegação, diferentes equipes ou departamentos podem gerenciar suas próprias zonas DNS, enquanto mantêm a integração com a infraestrutura DNS global.

Neste artigo final da série, abordaremos os conceitos, implementação e gerenciamento de delegação de subdomínios no BIND. Exploraremos desde os fundamentos teóricos até configurações práticas, incluindo delegação em ambientes com views, delegação segura com DNSSEC e estratégias para troubleshooting e manutenção.

Ao dominar a delegação de subdomínios, você terá todas as ferramentas necessárias para implementar uma infraestrutura DNS completa, escalável e bem organizada.

Conceitos Fundamentais de Delegação DNS

A delegação DNS é o processo pelo qual a responsabilidade por uma parte do espaço de nomes de domínio é transferida de uma autoridade DNS para outra.

Hierarquia DNS e Delegação

O DNS é organizado como uma estrutura hierárquica em forma de árvore invertida:

  1. Raiz (.): No topo da hierarquia, representada por um ponto
  2. Domínios de Primeiro Nível (TLDs): Como .com, .org, .net, .br, .us
  3. Domínios de Segundo Nível: Como example.com, google.com
  4. Subdomínios: Como dev.example.com, mail.example.com

A delegação ocorre quando um nível superior da hierarquia aponta para servidores autoritativos em um nível inferior, permitindo que esses servidores respondam por uma parte específica do espaço de nomes.

Benefícios da Delegação

A delegação de subdomínios oferece diversos benefícios:

  • Descentralização administrativa: Diferentes equipes podem gerenciar suas próprias zonas
  • Escalabilidade: Distribui a carga de consultas entre múltiplos servidores
  • Autonomia: Permite que departamentos ou filiais gerenciem seus próprios recursos DNS
  • Organização lógica: Reflete a estrutura organizacional na hierarquia DNS
  • Isolamento de falhas: Problemas em um subdomínio não afetam outros subdomínios

Registros NS e Glue Records

A delegação é implementada através de dois tipos principais de registros:

Registros NS (Name Server)

Os registros NS identificam os servidores autoritativos para uma zona:

1
2

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

Glue Records

Os glue records são registros A (ou AAAA) que fornecem os endereços IP dos servidores de nomes mencionados nos registros NS, quando esses servidores estão dentro da zona delegada:

1
2

ns1.subdominio.example.com.  IN A  192.168.200.51
ns2.subdominio.example.com.  IN A  192.168.200.52

Sem glue records, ocorreria uma dependência circular: para resolver ns1.subdominio.example.com, o resolvedor precisaria consultar os servidores autoritativos para subdominio.example.com, mas para encontrar esses servidores, ele precisaria resolver ns1.subdominio.example.com.

Fluxo de Resolução com Delegação

Quando um cliente tenta resolver um nome em um subdomínio delegado, o processo segue estas etapas:

  1. O cliente consulta um servidor recursivo
  2. O servidor recursivo consulta um servidor raiz
  3. O servidor raiz responde com referência aos servidores TLD
  4. O servidor recursivo consulta um servidor TLD
  5. O servidor TLD responde com referência aos servidores do domínio
  6. O servidor recursivo consulta um servidor do domínio
  7. O servidor do domínio responde com referência aos servidores do subdomínio (delegação)
  8. O servidor recursivo consulta um servidor do subdomínio
  9. O servidor do subdomínio responde com o registro solicitado
  10. O servidor recursivo retorna a resposta ao cliente
+---------+   Consulta www.dev.example.com   +-----------------+
| Cliente | -------------------------------> | Servidor Recurso  |
+---------+                                  +--------+--------+
                                                       |
                                                       V Consulta Raiz (.)
                                                +------v----------+
                                                | Servidor Raiz   |
                                                +-----------------+
                                                       | Resposta: Servidores .com
                                                       V
                                                +------v----------+
                                                | Servidor TLD .com |
                                                +-----------------+
                                                       | Resposta: Servidores example.com (ns1/ns2.example.com)
                                                       V
                                                +------v----------+
                                                | Servidor        |
                                                | example.com     |
                                                | (ns1.example.com)|
                                                +-----------------+
                                                       | Resposta: Delegação para dev.example.com
                                                       |           NS: ns1/ns2.dev.example.com
                                                       |           Glue: A ns1/ns2.dev.example.com
                                                       V
                                                +------v----------+
                                                | Servidor        |
                                                | dev.example.com |
                                                | (ns1.dev.example.com)|
                                                +-----------------+
                                                       | Resposta: A www.dev.example.com = 192.168.200.60
                                                       V
+---------+   Resposta: 192.168.200.60         +--------+--------+
| Cliente | <------------------------------- | Servidor Recurso  |
+---------+                                  +-----------------+

Figura 1: Fluxo de Resolução Detalhado com Delegação de Subdomínio

Planejamento de Delegação de Subdomínios

Antes de implementar a delegação, é importante realizar um planejamento adequado.

Estratégias de Nomeação

Adote uma estratégia de nomeação consistente para subdomínios:

  • Baseada em função: mail.example.com, www.example.com, db.example.com
  • Baseada em departamento: marketing.example.com, ti.example.com, rh.example.com
  • Baseada em localização: sp.example.com, rj.example.com, ny.example.com
  • Baseada em ambiente: dev.example.com, test.example.com, prod.example.com
  • Híbrida: dev.sp.example.com, prod.ny.example.com

Considerações de Infraestrutura

Ao planejar a delegação, considere:

  • Servidores dedicados: Cada subdomínio terá servidores DNS dedicados ou compartilhados?
  • Redundância: Quantos servidores NS serão configurados para cada subdomínio?
  • Localização: Onde os servidores estarão localizados fisicamente?
  • Conectividade: Como será a conectividade entre os servidores do domínio principal e os subdomínios?
  • Segurança: Como será implementada a segurança nas transferências de zona e atualizações?

Matriz de Responsabilidades

Defina claramente as responsabilidades:

AspectoEquipe do Domínio PrincipalEquipe do Subdomínio
Registros NS do subdomínioResponsávelConsultada
Glue recordsResponsávelConsultada
Configuração dos servidores do subdomínioConsultadaResponsável
Arquivos de zona do subdomínioInformadaResponsável
Monitoramento do subdomínioCompartilhadaCompartilhada
Resolução de problemasCompartilhadaCompartilhada

Documentação

Mantenha documentação detalhada sobre:

  • Estrutura de subdomínios
  • Servidores NS para cada subdomínio
  • Contatos responsáveis
  • Procedimentos de alteração
  • Procedimentos de troubleshooting

Implementação de Delegação de Subdomínios

Vamos implementar a delegação de um subdomínio chamado “dev.example.com” para servidores DNS dedicados.

Cenário

  • Domínio principal: example.com
  • Subdomínio: dev.example.com
  • Servidores do domínio principal:
    • ns1.example.com (192.168.200.49)
    • ns2.example.com (192.168.200.50)
  • Servidores do subdomínio:
    • ns1.dev.example.com (192.168.200.51)
    • ns2.dev.example.com (192.168.200.52)

Configuração no Servidor do Domínio Principal

Atualização do Arquivo de Zona

Edite o arquivo de zona do domínio principal para adicionar a delegação:

1

sudo vi /var/named/zones/example.com.zone

Adicione os registros NS e glue records:

1
2
3
4
5

; Delegação para dev.example.com
dev             IN NS   ns1.dev.example.com.
dev             IN NS   ns2.dev.example.com.
ns1.dev         IN A    192.168.200.51
ns2.dev         IN A    192.168.200.52

Observe que:

  • Os registros NS apontam para os servidores autoritativos do subdomínio
  • Os glue records fornecem os endereços IP desses servidores
  • Não é necessário incluir o domínio completo à esquerda (dev em vez de dev.example.com)

Incremente o número de série do SOA:

1
2
3
4
5
6

@       IN SOA  ns1.example.com. admin.example.com. (
                    2025052401  ; Serial (incrementado)
                    10800       ; Refresh (3 hours)
                    3600        ; Retry (1 hour)
                    604800      ; Expire (1 week)
                    86400 )     ; Minimum TTL (1 day)

Verificação e Recarregamento

Verifique a sintaxe do arquivo de zona:

1

sudo named-checkzone example.com /var/named/zones/example.com.zone

Recarregue a zona:

1

sudo rndc reload example.com

Configuração no Servidor do Subdomínio

Instalação do BIND

Se ainda não estiver instalado:

1

sudo dnf install bind bind-utils -y

Criação da Estrutura de Diretórios

1
2
3
4
5

sudo mkdir -p /var/named/zones
sudo chown -R root:named /var/named/zones
sudo chmod -R 750 /var/named/zones
sudo semanage fcontext -a -t named_zone_t "/var/named/zones(/.*)?"
sudo restorecon -Rv /var/named/zones

Configuração do named.conf

1

sudo vi /etc/named.conf

Adicione:

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

options {
    directory "/var/named";
    
    listen-on port 53 { 
        127.0.0.1;
        192.168.200.51;  // IP deste servidor
    };
    listen-on-v6 port 53 { ::1; };
    
    allow-query { any; };
    recursion no;  // Servidor autoritativo apenas
    
    // Configurações adicionais
    dnssec-validation auto;
    
    // Logging
    // ... (configuração de logging similar ao primário)
};

// Zona do subdomínio
zone "dev.example.com" IN {
    type master;
    file "zones/dev.example.com.zone";
    allow-transfer { 192.168.200.52; };  // Permitir transferência para o secundário
    also-notify { 192.168.200.52; };
    notify yes;
};

Criação do Arquivo de Zona do Subdomínio

1

sudo vi /var/named/zones/dev.example.com.zone

Adicione:

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

$TTL 86400
@       IN SOA  ns1.dev.example.com. admin.dev.example.com. (
                    2025052401  ; Serial
                    10800       ; Refresh (3 hours)
                    3600        ; Retry (1 hour)
                    604800      ; Expire (1 week)
                    86400 )     ; Minimum TTL (1 day)

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

ns1     IN A    192.168.200.51
ns2     IN A    192.168.200.52
www     IN A    192.168.200.60
app     IN A    192.168.200.61
db      IN A    192.168.200.62

Configuração de Permissões

1
2
3

sudo chown root:named /var/named/zones/dev.example.com.zone
sudo chmod 640 /var/named/zones/dev.example.com.zone
sudo restorecon -v /var/named/zones/dev.example.com.zone

Inicialização do Serviço

1

sudo systemctl enable --now named

Configuração do Firewall

1
2

sudo firewall-cmd --permanent --add-service=dns
sudo firewall-cmd --reload

Configuração do Servidor Secundário do Subdomínio

A configuração do servidor secundário do subdomínio é similar à configuração de um servidor secundário regular, como vimos no artigo anterior.

1
2
3
4
5
6

// Zona do subdomínio (no servidor secundário)
zone "dev.example.com" IN {
    type slave;
    masters { 192.168.200.51; };
    file "slaves/dev.example.com.zone";
};

Verificação da Delegação

Teste de Resolução

Teste a resolução de nomes no subdomínio:

1
2
3
4
5
6
7
8

# Consultar os servidores NS do subdomínio
dig NS dev.example.com

# Consultar um registro no subdomínio
dig www.dev.example.com

# Consultar com rastreamento completo
dig +trace www.dev.example.com

Verificação de Autoridade

Verifique se os servidores do subdomínio são realmente autoritativos:

1
2
3
4
5

# Consultar diretamente o servidor do subdomínio
dig @192.168.200.51 www.dev.example.com

# Verificar a seção de autoridade (AA flag)
dig @192.168.200.51 www.dev.example.com +norec

A resposta deve incluir a flag “aa” (authoritative answer).

Delegação em Ambientes com Views

A delegação em ambientes com views (Split-Horizon DNS) requer considerações especiais, pois você pode querer apresentar diferentes visões do mesmo subdomínio para clientes internos e externos.

Cenário

  • Domínio principal: example.com com views interna e externa
  • Subdomínio: dev.example.com, visível apenas internamente

Configuração no Servidor do Domínio Principal

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

view "internal" {
    match-clients { internal_clients; };
    
    zone "example.com" IN {
        type master;
        file "zones/internal/example.com.zone";
        // ...
    };
};

view "external" {
    match-clients { any; };
    
    zone "example.com" IN {
        type master;
        file "zones/external/example.com.zone";
        // ...
    };
};

Arquivo de Zona Interna

No arquivo /var/named/zones/internal/example.com.zone, adicione a delegação:

1
2
3
4
5

; Delegação para dev.example.com (apenas na view interna)
dev             IN NS   ns1.dev.example.com.
dev             IN NS   ns2.dev.example.com.
ns1.dev         IN A    192.168.200.51
ns2.dev         IN A    192.168.200.52

Arquivo de Zona Externa

No arquivo /var/named/zones/external/example.com.zone, não inclua a delegação para manter o subdomínio invisível externamente.

Configuração no Servidor do Subdomínio

A configuração no servidor do subdomínio permanece a mesma, mas você pode adicionar controles de acesso para permitir consultas apenas de redes internas:

1
2
3
4
5
6
7
8
9
10

options {
    // ...
    allow-query { internal_clients; };
    // ...
};

acl "internal_clients" {
    localhost;
    192.168.200.0/24;
};

Verificação da Delegação com Views

Teste a resolução de diferentes perspectivas:

1
2
3
4
5

# De um cliente interno
dig @192.168.200.49 dev.example.com NS

# De um cliente externo (não deve resolver)
dig @203.0.113.1 dev.example.com NS

Delegação Segura com DNSSEC

A delegação com DNSSEC adiciona uma camada de segurança, garantindo a autenticidade e integridade dos dados DNS através da cadeia de confiança.

Conceitos de DNSSEC na Delegação

Na delegação com DNSSEC, além dos registros NS e glue records, são necessários registros DS (Delegation Signer) que contêm hashes das chaves DNSSEC do subdomínio, criando uma cadeia de confiança.

Configuração de DNSSEC no Subdomínio

Geração de Chaves DNSSEC

No servidor do subdomínio:

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

# Criar diretório para chaves
sudo mkdir -p /var/named/keys
sudo chown named:named /var/named/keys
sudo chmod 750 /var/named/keys

# Gerar chave de assinatura de zona (ZSK)
sudo dnssec-keygen -a ECDSAP256SHA256 -b 256 -n ZONE dev.example.com

# Gerar chave de assinatura de chave (KSK)
sudo dnssec-keygen -a ECDSAP256SHA256 -b 256 -f KSK -n ZONE dev.example.com

# Mover as chaves para o diretório apropriado
sudo mv K*.key K*.private /var/named/keys/
sudo chown named:named /var/named/keys/K*
sudo chmod 640 /var/named/keys/K*

Configuração de DNSSEC no named.conf

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

options {
    // ...
    dnssec-validation auto;
    dnssec-enable yes;
};

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

Assinatura da Zona

Se não estiver usando inline-signing:

1

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

Geração de Registro DS

1
2

# Gerar registro DS a partir da KSK
sudo dnssec-dsfromkey /var/named/keys/Kdev.example.com.+013+xxxxx.key

O comando acima produzirá uma saída como:

1

dev.example.com. IN DS 12345 13 2 1A2B3C4D5E6F7G8H9I0J1K2L3M4N5O6P7Q8R9S0T1U2V3W4X5Y6Z7

Configuração de DNSSEC no Domínio Principal

Adição do Registro DS

Edite o arquivo de zona do domínio principal:

1

sudo vi /var/named/zones/example.com.zone

Adicione o registro DS gerado:

1
2
3
4
5
6

; Delegação para dev.example.com com DNSSEC
dev             IN NS   ns1.dev.example.com.
dev             IN NS   ns2.dev.example.com.
dev             IN DS   12345 13 2 1A2B3C4D5E6F7G8H9I0J1K2L3M4N5O6P7Q8R9S0T1U2V3W4X5Y6Z7
ns1.dev         IN A    192.168.200.51
ns2.dev         IN A    192.168.200.52

Incremente o número de série e assine a zona do domínio principal (se estiver usando DNSSEC).

Verificação da Delegação Segura

1
2
3
4
5
6
7
8
9

# Verificar a cadeia de confiança
dig +dnssec +trace www.dev.example.com

# Verificar registros DNSSEC específicos
dig DNSKEY dev.example.com
dig DS dev.example.com

# Usar ferramentas específicas de DNSSEC
dnssec-verify dev.example.com.signed

Delegação para Diferentes Tipos de Subdomínios

Vamos explorar diferentes cenários de delegação para casos de uso específicos.

Delegação para Subdomínios Departamentais

Neste cenário, cada departamento gerencia seu próprio subdomínio.

Exemplo: Subdomínio de Marketing

1
2
3
4
5

; No arquivo de zona example.com
marketing       IN NS   ns1.marketing.example.com.
marketing       IN NS   ns2.marketing.example.com.
ns1.marketing   IN A    192.168.201.51
ns2.marketing   IN A    192.168.201.52

Exemplo: Subdomínio de TI

1
2
3
4
5

; No arquivo de zona example.com
ti              IN NS   ns1.ti.example.com.
ti              IN NS   ns2.ti.example.com.
ns1.ti          IN A    192.168.202.51
ns2.ti          IN A    192.168.202.52

Delegação para Subdomínios Geográficos

Neste cenário, cada localidade geográfica gerencia seu próprio subdomínio.

Exemplo: Subdomínio de São Paulo

1
2
3
4
5

; No arquivo de zona example.com
sp              IN NS   ns1.sp.example.com.
sp              IN NS   ns2.sp.example.com.
ns1.sp          IN A    192.168.210.51
ns2.sp          IN A    192.168.210.52

Exemplo: Subdomínio do Rio de Janeiro

1
2
3
4
5

; No arquivo de zona example.com
rj              IN NS   ns1.rj.example.com.
rj              IN NS   ns2.rj.example.com.
ns1.rj          IN A    192.168.220.51
ns2.rj          IN A    192.168.220.52

Delegação para Subdomínios de Ambiente

Neste cenário, cada ambiente (desenvolvimento, teste, produção) tem seu próprio subdomínio.

Exemplo: Subdomínio de Desenvolvimento

1
2
3
4
5

; No arquivo de zona example.com
dev             IN NS   ns1.dev.example.com.
dev             IN NS   ns2.dev.example.com.
ns1.dev         IN A    192.168.200.51
ns2.dev         IN A    192.168.200.52

Exemplo: Subdomínio de Teste

1
2
3
4
5

; No arquivo de zona example.com
test            IN NS   ns1.test.example.com.
test            IN NS   ns2.test.example.com.
ns1.test        IN A    192.168.200.61
ns2.test        IN A    192.168.200.62

Delegação para Subdomínios de Projetos

Neste cenário, cada projeto importante tem seu próprio subdomínio.

Exemplo: Subdomínio do Projeto Alpha

1
2
3
4
5

; No arquivo de zona example.com
alpha           IN NS   ns1.alpha.example.com.
alpha           IN NS   ns2.alpha.example.com.
ns1.alpha       IN A    192.168.230.51
ns2.alpha       IN A    192.168.230.52

Delegação Reversa

A delegação reversa segue os mesmos princípios da delegação direta, mas para zonas de resolução reversa (PTR).

Cenário

  • Zona reversa principal: 200.168.192.in-addr.arpa
  • Subrede delegada: 192.168.201.0/24 (201.200.168.192.in-addr.arpa)

Configuração no Servidor da Zona Reversa Principal

Edite o arquivo de zona reversa:

1

sudo vi /var/named/zones/200.168.192.in-addr.arpa.zone

Adicione a delegação:

1
2
3

; Delegação reversa para 192.168.201.0/24
201             IN NS   ns1.marketing.example.com.
201             IN NS   ns2.marketing.example.com.

Configuração no Servidor do Subdomínio

1
2
3
4
5
6
7

zone "201.200.168.192.in-addr.arpa" IN {
    type master;
    file "zones/201.200.168.192.in-addr.arpa.zone";
    allow-transfer { 192.168.201.52; };
    also-notify { 192.168.201.52; };
    notify yes;
};

Crie o arquivo de zona reversa:

1

sudo vi /var/named/zones/201.200.168.192.in-addr.arpa.zone

Adicione:

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

$TTL 86400
@       IN SOA  ns1.marketing.example.com. admin.marketing.example.com. (
                    2025052401  ; Serial
                    10800       ; Refresh (3 hours)
                    3600        ; Retry (1 hour)
                    604800      ; Expire (1 week)
                    86400 )     ; Minimum TTL (1 day)

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

1       IN PTR  router.marketing.example.com.
10      IN PTR  server1.marketing.example.com.
11      IN PTR  server2.marketing.example.com.
20      IN PTR  printer1.marketing.example.com.

Verificação da Delegação Reversa

1
2
3
4
5

# Consultar os servidores NS da zona reversa delegada
dig NS 201.200.168.192.in-addr.arpa

# Consultar um registro PTR na zona delegada
dig -x 192.168.201.10

Troubleshooting de Delegação

A delegação pode apresentar diversos problemas. Vamos explorar os mais comuns e suas soluções.

Problema: Falha na Resolução de Nomes no Subdomínio

Sintomas:

  • Consultas para o subdomínio retornam SERVFAIL ou NXDOMAIN
  • O comando dig +trace não completa corretamente

Verificações:

1
2
3
4
5
6
7
8

# Verificar registros NS no domínio principal
dig NS dev.example.com

# Verificar se os servidores NS estão respondendo
dig @ns1.dev.example.com dev.example.com SOA

# Verificar glue records
dig dev.example.com NS +additional

Possíveis Causas e Soluções:

  1. Registros NS incorretos ou ausentes:
    • Verifique se os registros NS estão corretamente configurados no domínio principal
    • Verifique se o número de série foi incrementado e a zona recarregada
  2. Glue records ausentes ou incorretos:
    • Verifique se os glue records estão presentes e corretos
    • Certifique-se de que os IPs correspondem aos servidores reais
  3. Servidores do subdomínio não estão respondendo:
    • Verifique se o serviço BIND está em execução nos servidores do subdomínio
    • Verifique conectividade de rede e regras de firewall
  4. Configuração incorreta no servidor do subdomínio:
    • Verifique se a zona está configurada corretamente no named.conf
    • Verifique se o arquivo de zona existe e tem a sintaxe correta

Problema: Inconsistência entre Servidores

Sintomas:

  • Diferentes respostas dependendo do servidor consultado
  • Transferências de zona falham

Verificações:

1
2
3
4
5
6
7
8
9

# Comparar respostas de diferentes servidores
dig @ns1.dev.example.com www.dev.example.com
dig @ns2.dev.example.com www.dev.example.com

# Verificar configuração de transferência de zona
grep "allow-transfer" /etc/named.conf

# Verificar logs de transferência
grep "transfer" /var/log/named/general.log

Possíveis Causas e Soluções:

  1. Falha nas transferências de zona:
    • Verifique se allow-transfer está configurado corretamente
    • Verifique se as ACLs permitem transferências
    • Se estiver usando TSIG, verifique se as chaves estão corretas
  2. Servidores secundários desatualizados:
    • Force uma transferência de zona: rndc retransfer dev.example.com
    • Verifique se as notificações estão habilitadas: notify yes;
  3. Configurações inconsistentes:
    • Compare os arquivos named.conf em todos os servidores
    • Verifique se todos os servidores têm a mesma versão do BIND

Problema: Falhas com DNSSEC

Sintomas:

  • Consultas com DNSSEC retornam SERVFAIL
  • Validação DNSSEC falha

Verificações:

1
2
3
4
5
6
7
8
9
10
11

# Verificar cadeia de confiança
dig +dnssec +trace www.dev.example.com

# Verificar registros DS no domínio principal
dig DS dev.example.com

# Verificar registros DNSKEY no subdomínio
dig @ns1.dev.example.com DNSKEY dev.example.com

# Usar ferramentas de diagnóstico DNSSEC
dnssec-verify dev.example.com.signed

Possíveis Causas e Soluções:

  1. Registro DS ausente ou incorreto:
    • Verifique se o registro DS está presente no domínio principal
    • Regenere o registro DS e atualize o domínio principal
  2. Chaves DNSSEC expiradas ou inválidas:
    • Verifique a validade das chaves: dnssec-verify
    • Regenere as chaves se necessário
  3. Assinatura da zona falhou:
    • Verifique logs de erro durante a assinatura
    • Tente assinar manualmente a zona
  4. Cadeia de confiança quebrada:
    • Verifique se o domínio principal também está assinado
    • Use ferramentas como DNSViz para visualizar a cadeia de confiança

Problema: Delegação Circular

Sintomas:

  • Consultas entram em loop
  • Respostas com referências circulares

Verificações:

1
2

# Verificar o caminho de resolução
dig +trace +additional www.dev.example.com

Possíveis Causas e Soluções:

  1. Configuração circular de servidores NS:
    • Verifique se não há referências circulares entre domínios e subdomínios
    • Certifique-se de que os servidores NS do subdomínio não dependem do próprio subdomínio para resolução
  2. Glue records ausentes:
    • Adicione glue records para todos os servidores NS que estão dentro do domínio delegado

Script de Verificação de Delegação

Aqui está um script abrangente para verificar a configuração de delegaçã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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

#!/bin/bash
# Script para verificar delegação de subdomínio

# Parâmetros
SUBDOMAIN=$1
DOMAIN=$2

if [ -z "$SUBDOMAIN" ] || [ -z "$DOMAIN" ]; then
    echo "Uso: $0 subdominio dominio"
    echo "Exemplo: $0 dev example.com"
    exit 1
fi

FQDN="${SUBDOMAIN}.${DOMAIN}"

echo "=== Verificação de Delegação para ${FQDN} ==="
echo

echo "=== Verificando Registros NS no Domínio Principal ==="
dig NS ${FQDN} +short
echo

echo "=== Verificando Glue Records ==="
dig NS ${FQDN} +additional
echo

echo "=== Verificando Resposta Autoritativa do Subdomínio ==="
for ns in $(dig NS ${FQDN} +short); do
    echo "Consultando $ns..."
    dig @$ns SOA ${FQDN} +norec
    echo
done

echo "=== Verificando Resolução Completa ==="
dig +trace ${FQDN}
echo

echo "=== Verificando DNSSEC (se aplicável) ==="
dig DS ${FQDN} +short
if [ -n "$(dig DS ${FQDN} +short)" ]; then
    echo "Registros DS encontrados, verificando cadeia DNSSEC..."
    dig +dnssec +trace ${FQDN}
    
    echo "Verificando DNSKEY no subdomínio..."
    for ns in $(dig NS ${FQDN} +short); do
        echo "Consultando $ns..."
        dig @$ns DNSKEY ${FQDN} +dnssec
        echo
    done
else
    echo "Nenhum registro DS encontrado, DNSSEC não configurado ou cadeia quebrada."
fi
echo

echo "=== Verificação de Delegação Concluída ==="

Melhores Práticas para Delegação

Redundância e Disponibilidade

  • Múltiplos servidores NS: Configure pelo menos dois servidores NS para cada subdomínio
  • Diversidade geográfica: Distribua servidores em diferentes locais
  • Diversidade de rede: Use diferentes provedores de rede
  • Monitoramento: Implemente monitoramento contínuo de todos os servidores NS

Segurança

  • Transferências de zona seguras: Use TSIG para proteger transferências de zona
  • DNSSEC: Implemente DNSSEC em toda a hierarquia
  • Controle de acesso: Restrinja consultas e transferências apenas a IPs autorizados
  • Logging: Mantenha logs detalhados para auditoria e troubleshooting

Desempenho

  • TTLs apropriados: Use TTLs adequados para balancear cache e atualização
  • Servidores dimensionados: Garanta que os servidores tenham recursos suficientes
  • Proximidade: Posicione servidores próximos aos usuários
  • Balanceamento de carga: Distribua consultas entre múltiplos servidores

Administração

  • Documentação: Mantenha documentação detalhada e atualizada
  • Procedimentos: Estabeleça procedimentos claros para alterações
  • Automação: Automatize tarefas repetitivas
  • Testes: Teste regularmente a resolução e failover

Governança

  • Políticas de nomeação: Estabeleça políticas claras para nomeação de subdomínios
  • Processo de aprovação: Defina um processo para aprovação de novos subdomínios
  • Revisões periódicas: Revise regularmente a estrutura de delegação
  • Responsabilidades: Defina claramente as responsabilidades de cada equipe

Automação de Delegação

A automação pode simplificar significativamente o gerenciamento de delegação de subdomínios.

Script para Criar Novo Subdomínio

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

#!/bin/bash
# Script para criar e delegar novo subdomínio

# Parâmetros
SUBDOMAIN=$1
DOMAIN=$2
NS1_IP=$3
NS2_IP=$4

if [ -z "$SUBDOMAIN" ] || [ -z "$DOMAIN" ] || [ -z "$NS1_IP" ] || [ -z "$NS2_IP" ]; then
    echo "Uso: $0 subdominio dominio ns1_ip ns2_ip"
    echo "Exemplo: $0 dev example.com 192.168.200.51 192.168.200.52"
    exit 1
fi

FQDN="${SUBDOMAIN}.${DOMAIN}"
ZONE_FILE="/var/named/zones/${DOMAIN}.zone"
NAMED_CONF="/etc/named.conf"

# Verificar se o subdomínio já existe
if grep -q "^${SUBDOMAIN}[[:space:]]\+IN[[:space:]]\+NS" $ZONE_FILE; then
    echo "Erro: Subdomínio $FQDN já existe."
    exit 1
fi

# Backup do arquivo de zona
cp $ZONE_FILE ${ZONE_FILE}.bak

# Incrementar o número de série
SERIAL=$(grep "Serial" $ZONE_FILE | head -1 | awk '{print $1}')
NEW_SERIAL=$(date +%Y%m%d01)
if [ $NEW_SERIAL -le $SERIAL ]; then
    NEW_SERIAL=$((SERIAL + 1))
fi
sed -i "s/$SERIAL[[:space:]]*;[[:space:]]*Serial/$NEW_SERIAL  ; Serial/" $ZONE_FILE

# Adicionar delegação
cat >> $ZONE_FILE << EOF

; Delegação para ${FQDN}
${SUBDOMAIN}             IN NS   ns1.${SUBDOMAIN}.${DOMAIN}.
${SUBDOMAIN}             IN NS   ns2.${SUBDOMAIN}.${DOMAIN}.
ns1.${SUBDOMAIN}         IN A    ${NS1_IP}
ns2.${SUBDOMAIN}         IN A    ${NS2_IP}
EOF

# Verificar sintaxe
named-checkzone $DOMAIN $ZONE_FILE
if [ $? -ne 0 ]; then
    echo "Erro na sintaxe da zona. Revertendo alterações."
    mv ${ZONE_FILE}.bak $ZONE_FILE
    exit 1
fi

# Recarregar zona
rndc reload $DOMAIN
if [ $? -ne 0 ]; then
    echo "Erro ao recarregar zona. Revertendo alterações."
    mv ${ZONE_FILE}.bak $ZONE_FILE
    exit 1
fi

echo "Delegação para $FQDN criada com sucesso."
echo "Não esqueça de configurar os servidores NS do subdomínio."

Automação com Ansible

Crie um playbook Ansible para automatizar a delegaçã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
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

---
- name: Configurar Delegação de Subdomínio
  hosts: dns_servers
  become: yes
  vars:
    subdomain: "dev"
    domain: "example.com"
    ns1_ip: "192.168.200.51"
    ns2_ip: "192.168.200.52"
  
  tasks:
    - name: Verificar se o subdomínio já existe
      shell: grep -q "^{{ subdomain }}[[:space:]]\+IN[[:space:]]\+NS" /var/named/zones/{{ domain }}.zone
      register: subdomain_exists
      ignore_errors: yes
      changed_when: false
    
    - name: Falhar se o subdomínio já existe
      fail:
        msg: "Subdomínio {{ subdomain }}.{{ domain }} já existe."
      when: subdomain_exists.rc == 0
    
    - name: Obter número de série atual
      shell: grep "Serial" /var/named/zones/{{ domain }}.zone | head -1 | awk '{print $1}'
      register: serial_result
      changed_when: false
    
    - name: Calcular novo número de série
      set_fact:
        current_serial: "{{ serial_result.stdout | int }}"
        date_serial: "{{ '%Y%m%d01' | strftime | int }}"
    
    - name: Definir número de série final
      set_fact:
        new_serial: "{{ date_serial if date_serial > current_serial else current_serial + 1 }}"
    
    - name: Atualizar número de série
      replace:
        path: /var/named/zones/{{ domain }}.zone
        regexp: '(\s+){{ current_serial }}(\s+;.*Serial)'
        replace: '\1{{ new_serial }}\2'
    
    - name: Adicionar delegação ao arquivo de zona
      blockinfile:
        path: /var/named/zones/{{ domain }}.zone
        block: |
          ; Delegação para {{ subdomain }}.{{ domain }}
          {{ subdomain }}             IN NS   ns1.{{ subdomain }}.{{ domain }}.
          {{ subdomain }}             IN NS   ns2.{{ subdomain }}.{{ domain }}.
          ns1.{{ subdomain }}         IN A    {{ ns1_ip }}
          ns2.{{ subdomain }}         IN A    {{ ns2_ip }}
    
    - name: Verificar sintaxe da zona
      command: named-checkzone {{ domain }} /var/named/zones/{{ domain }}.zone
      register: checkzone_result
      changed_when: false
      failed_when: checkzone_result.rc != 0
    
    - name: Recarregar zona
      command: rndc reload {{ domain }}
      register: reload_result
      failed_when: reload_result.rc != 0
    
    - name: Notificar sucesso
      debug:
        msg: "Delegação para {{ subdomain }}.{{ domain }} criada com sucesso."

API REST para Gerenciamento de Delegação

Para ambientes maiores, considere implementar uma API REST para gerenciamento de delegaçã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
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

from flask import Flask, request, jsonify
import subprocess
import re
import os

app = Flask(__name__)

@app.route('/api/delegation', methods=['POST'])
def create_delegation():
    data = request.json
    
    # Validar parâmetros
    required_params = ['subdomain', 'domain', 'ns1_ip', 'ns2_ip']
    for param in required_params:
        if param not in data:
            return jsonify({'error': f'Parâmetro {param} ausente'}), 400
    
    subdomain = data['subdomain']
    domain = data['domain']
    ns1_ip = data['ns1_ip']
    ns2_ip = data['ns2_ip']
    
    # Validar formato
    if not re.match(r'^[a-z0-9-]+$', subdomain):
        return jsonify({'error': 'Formato de subdomínio inválido'}), 400
    
    zone_file = f'/var/named/zones/{domain}.zone'
    
    # Verificar se o arquivo de zona existe
    if not os.path.exists(zone_file):
        return jsonify({'error': f'Arquivo de zona para {domain} não encontrado'}), 404
    
    # Verificar se o subdomínio já existe
    try:
        result = subprocess.run(['grep', '-q', f'^{subdomain}[[:space:]]+IN[[:space:]]+NS', zone_file])
        if result.returncode == 0:
            return jsonify({'error': f'Subdomínio {subdomain}.{domain} já existe'}), 409
    except Exception as e:
        return jsonify({'error': str(e)}), 500
    
    # Implementar lógica de delegação
    try:
        # Backup do arquivo de zona
        subprocess.run(['cp', zone_file, f'{zone_file}.bak'], check=True)
        
        # Obter e incrementar número de série
        serial_cmd = f"grep 'Serial' {zone_file} | head -1 | awk '{{print $1}}'"
        serial = subprocess.check_output(serial_cmd, shell=True).decode().strip()
        
        date_serial = subprocess.check_output('date +%Y%m%d01', shell=True).decode().strip()
        if int(date_serial) <= int(serial):
            new_serial = int(serial) + 1
        else:
            new_serial = int(date_serial)
        
        # Atualizar número de série
        subprocess.run(['sed', '-i', f's/{serial}[[:space:]]*;[[:space:]]*Serial/{new_serial}  ; Serial/', zone_file], check=True)
        
        # Adicionar delegação
        with open(zone_file, 'a') as f:
            f.write(f'''
; Delegação para {subdomain}.{domain}
{subdomain}             IN NS   ns1.{subdomain}.{domain}.
{subdomain}             IN NS   ns2.{subdomain}.{domain}.
ns1.{subdomain}         IN A    {ns1_ip}
ns2.{subdomain}         IN A    {ns2_ip}
''')
        
        # Verificar sintaxe
        result = subprocess.run(['named-checkzone', domain, zone_file], capture_output=True)
        if result.returncode != 0:
            # Reverter alterações
            subprocess.run(['mv', f'{zone_file}.bak', zone_file])
            return jsonify({'error': f'Erro na sintaxe da zona: {result.stderr.decode()}'}), 400
        
        # Recarregar zona
        result = subprocess.run(['rndc', 'reload', domain], capture_output=True)
        if result.returncode != 0:
            # Reverter alterações
            subprocess.run(['mv', f'{zone_file}.bak', zone_file])
            return jsonify({'error': f'Erro ao recarregar zona: {result.stderr.decode()}'}), 500
        
        return jsonify({
            'status': 'success',
            'message': f'Delegação para {subdomain}.{domain} criada com sucesso',
            'subdomain': subdomain,
            'domain': domain,
            'fqdn': f'{subdomain}.{domain}',
            'ns1': f'ns1.{subdomain}.{domain}',
            'ns2': f'ns2.{subdomain}.{domain}',
            'ns1_ip': ns1_ip,
            'ns2_ip': ns2_ip
        })
    
    except Exception as e:
        # Tentar reverter alterações
        try:
            subprocess.run(['mv', f'{zone_file}.bak', zone_file])
        except:
            pass
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Conclusão

Neste artigo final da nossa série sobre DNS BIND no Oracle Linux 9, exploramos a delegação e gerenciamento de subdomínios. Abordamos desde os conceitos fundamentais até implementações práticas, incluindo delegação em ambientes com views, delegação segura com DNSSEC, troubleshooting e automação.

A delegação de subdomínios é uma técnica poderosa que permite criar uma infraestrutura DNS escalável, bem organizada e descentralizada. Ao dominar esses conceitos e técnicas, você está preparado para implementar e gerenciar infraestruturas DNS complexas em ambientes corporativos e de provedores de serviço.

Recapitulação da Série

Ao longo desta série de oito artigos, cobrimos todos os aspectos da implementação e gerenciamento de servidores DNS BIND no Oracle Linux 9:

  1. Fundamentos do DNS e Preparação: Conceitos básicos, hierarquia DNS e planejamento
  2. Instalação e Configuração Básica: Instalação do BIND e configuração inicial
  3. Configuração de Zonas DNS: Criação e gerenciamento de zonas diretas e reversas
  4. Views e DNS Split-Horizon: Configuração de diferentes visões do DNS para diferentes clientes
  5. Segurança e Hardening: Proteção do servidor DNS contra ameaças
  6. Logging, Monitoramento e Troubleshooting: Diagnóstico e resolução de problemas
  7. Configurações Avançadas: Servidor secundário, chroot, alta disponibilidade e integração com DHCP
  8. Delegação e Subdomínios: Implementação e gerenciamento de delegação

Esperamos que esta série tenha fornecido o conhecimento e as ferramentas necessárias para implementar, configurar e gerenciar servidores DNS BIND com confiança e competência.

Referências e Recursos Adicionais

Servidores, DNS, Linux
BIND DNS Oracle Linux Delegação Subdomínios
This post is licensed under CC BY 4.0 by the author.