Docker bridge 网络与自定义 DNS 解析

1
2
3

nameserver 8.8.8.8
nameserver 8.8.4.4
search example.com

1

search xae-zcbus-20230523.28e5df10.csphere.local csphere.local

1
2
3
4
5

# 安装 pdns
yum install pdns pdns-backend-pipe -y

# pdns 启动,停止和查看是否运行正常
systemctl start/stop/status pdns

1

/usr/sbin/pdns_server --guardian=no --daemon=no --disable-syslog --log-timestamp=no --write-pid=no

1
2

launch=pipe
pipe-command=/path/to/your/script.py

1
2
3
4
5
6
7
8

# 安装 dnsmasq
yum install dnsmasq

# 一些状态命令
systemctl start/stop/restart/status dnsmasq

# 检查配置文件语法是否正确
dnsmasq --test

1
2

server=8.8.8.8
server=8.8.4.4

1

server=/domain.org/192.168.14.5

1
2

address=/域名/IP地址
address=/example.com/192.168.1.100

  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

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os
import random
import sys
import time


class DNSLookup(object):
    """Handle PowerDNS pipe-backend domain name lookups."""
    ttl = 30

    def __init__(self, query):
        """parse DNS query and produce lookup result.

        query: a sequence containing the DNS query as per PowerDNS manual appendix A:
        http://downloads.powerdns.com/documentation/html/backends-detail.html#PIPEBACKEND-PROTOCOL
        """
        (_type, qname, qclass, qtype, _id, ip) = query
        self.has_result = False  # has a DNS query response
        qname_lower = qname.lower()

        """List of servers to round-robin"""
        servers = ['192.168.40.223']
        server = random.choice(servers)

        self.results = []

        # if (qtype == 'A' or qtype == 'ANY') and qname_lower.endswith('domain.org'):
        if qtype == 'ANY' and qname_lower.endswith('domain.org'):
            self.results.append('DATA\t%s\t%s\tA\t%d\t-1\t%s' % (qname, qclass, DNSLookup.ttl, server))
            self.has_result = True
        elif qtype == 'SOA':
            self.results.append(
                'DATA\t%s\t%s\t%s\t3600\t-1\tns1.test.soa\tadmin.test.soa\t2014032110\t10800\t3600\t604800\t3600'
                % (qname, qclass, qtype))
            self.has_result = True

    def str_result(self):
        """return string result suitable for pipe-backend output to PowerDNS."""
        if self.has_result:
            return '\n'.join(self.results)
        else:
            return ''


class Logger(object):
    def __init__(self):
        pid = os.getpid()
        self.logfile = '/tmp/backend.log'
        """self.logfile = '/tmp/backend-%d.log' % pid"""

    def write(self, msg):
        logline = '%s|%s\n' % (time.asctime(), msg)
        f = open(self.logfile, 'a')
        f.write(logline)
        f.close()


def debug_log(msg):
    logger.write(msg)


class PowerDNSbackend(object):
    """The main PowerDNS pipe backend process."""

    def __init__(self, filein, fileout):
        """initialise and run PowerDNS pipe backend process."""
        self.filein = filein
        self.fileout = fileout

        self._process_requests()  # main program loop

    def _process_requests(self):
        """main program loop"""
        first_time = True
        while 1:
            rawline = self.filein.readline()
            if rawline == '':
                debug_log('EOF')
                return  # EOF detected
            line = rawline.rstrip()

            debug_log('received from pdns:%s' % line)

            if first_time:
                if line == 'HELO\t1':
                    self._fprint('OK\tPython backend firing up')
                else:
                    self._fprint('FAIL')
                    debug_log('HELO input not received - execution aborted')
                    rawline = self.filein.readline()  # as per docs - read another line before aborting
                    debug_log('calling sys.exit()')
                    sys.exit(1)
                first_time = False
            else:
                query = line.split('\t')
                if len(query) != 6:
                    self._fprint('LOG\tPowerDNS sent unparseable line')
                    self._fprint('FAIL')
                else:
                    debug_log('Performing DNSLookup(%s)' % repr(query))
                    lookup = DNSLookup(query)
                    if lookup.has_result:
                        pdns_result = lookup.str_result()
                        self._fprint(pdns_result)
                        debug_log('DNSLookup result(%s)' % pdns_result)
                    self._fprint('END')

    def _fprint(self, message):
        """Print the given message with newline and flushing."""
        self.fileout.write(message + '\n')
        self.fileout.flush()
        debug_log('sent to pdns:%s' % message)


if __name__ == '__main__':
    logger = Logger()
    infile = sys.stdin
    # sys.stdout.close()
    # outfile = os.fdopen(1, 'w', 1)
    outfile = sys.stdout
    try:
        PowerDNSbackend(infile, outfile)
    except:
        debug_log('execution failure:' + str(sys.exc_info()[0]))
        raise

1

docker run --name c-redis --dns 172.17.0.1 --dns-search domain.org --dns-opt "ndots:2" -d  xiaobinqt/redis:7-ping