在 kubernetes 的本地环境中使用主机名连接到 docker 容器

Question

我有一个 kubernete docker-compose 包含

frontend - a web app running on port 80
backend - a node server for API running on port 80
database - mongodb

我想理想地通过主机名访问frontend ，例如http://frontend:80 ，并且浏览器能够通过主机名访问backend ，例如http://backend:80 ，这是网络所需的客户端的应用程序。

如何通过本地主机环境（Windows）上的这些主机名访问我的容器？

---

docker-compose.yml

version: "3.8"
services:
    frontend:
        build: frontend
        hostname: framework
        ports:
            - "80:80"
            - "443:443"
            - "33440:33440"
    backend:
        build: backend
        hostname: backend
    database:
        image: 'mongo'
        environment:
            - MONGO_INITDB_DATABASE=framework-database
        volumes:
            - ./mongo/mongo-volume:/data/database
            - ./mongo/init-mongo.js:/docker-entrypoint-initdb.d/init-mongo.js:ro
        ports:
            - '27017-27019:27017-27019'

Answer 1

我能够弄清楚，使用 docker-compose 别名和网络，我能够将每个容器连接到同一个开发网络。

有3个主要组成部分：

• 容器映射节点 dns 服务器- 通过docker ps获取别名并创建一个 DNS 服务器，将这些请求重定向到127.0.0.1 (localhost)
• nginx 反向代理容器- 通过虚拟网络中的别名将主机映射到容器
• 项目- 每个项目都是一个docker-compose.yml ，可以在端口 80 上运行无限数量的容器

clientA 的 docker-compose.yml

version: "3.8"
services:
    frontend:
        build: frontend
        container_name: clienta-frontend
        networks:
            default:
                aliases:
                    - clienta.test
    backend:
        build: backend
        container_name: clienta-backend
        networks:
            default:
                aliases:
                    - api.clienta.test
networks:
    default:
        external: true # connect to external network (see below for more)
        name: 'development' # name of external network

nginx 代理docker-compose.yml

version: '3'
services: 
    parent:
        image: nginx:alpine
        volumes:
            - ./nginx.conf:/etc/nginx/nginx.conf
        ports:
            - "80:80" #map port 80 to localhost
        networks:
            - development
networks:
    development: #create network called development
        name: 'development'
        driver: bridge

DNS服务器

import dns from 'native-dns'
import { exec } from 'child_process'

const { createServer, Request } = dns
const authority = { address: '8.8.8.8', port: 53, type: 'udp' }
const hosts = {}

let server = createServer()

function command (cmd) {
    return new Promise((resolve, reject) => {
        exec(cmd, (err, stdout, stderr) => stdout ? resolve(stdout) : reject(stderr ?? err))
    })
}
async function getDockerHostnames(){
    let containersText = await command('docker ps --format "{{.ID}}"')
    let containers = containersText.split('\n')
    containers.pop()
    await Promise.all(containers.map(async containerID => {
        let json = JSON.parse(await command(`docker inspect ${containerID}`))?.[0]
        let aliases = json?.NetworkSettings?.Networks?.development?.Aliases || []
        aliases.map(alias => hosts[alias] = {
            domain: `^${alias}*`,
            records: [
                { type: 'A', address: '127.0.0.1', ttl: 100 }
            ]
        })
    }))
}

await getDockerHostnames()
setInterval(getDockerHostnames, 8000)

function proxy(question, response, cb) {
    var request = Request({
        question: question, // forwarding the question
        server: authority,  // this is the DNS server we are asking
        timeout: 1000
    })

    // when we get answers, append them to the response
    request.on('message', (err, msg) => {
        msg.answer.map(a => response.answer.push(a))
    });

    request.on('end', cb)
    request.send()
}

server.on('close', () => console.log('server closed', server.address()))
server.on('error', (err, buff, req, res) => console.error(err.stack))
server.on('socketError', (err, socket) => console.error(err))
server.on('request', async function handleRequest(request, response) {
    await Promise.all(request.question.map(question => {
        console.log(question.name)
        let entry = Object.values(hosts).find(r => new RegExp(r.domain, 'i').test(question.name))
        if (entry) {
            entry.records.map(record => {
                record.name = question.name;
                record.ttl = record.ttl ?? 600;
                return response.answer.push(dns[record.type](record));
            })
        } else {
            return new Promise(resolve => proxy(question, response, resolve))
        }
    }))

    response.send()
});

server.serve(53, '127.0.0.1');

不要忘记更新您的计算机网络设置以使用127.0.0.1作为 DNS 服务器

dns 服务器 + nginx 代理的 Git 存储库，以防您想查看实现： https : //github.com/framework-tools/dockerdnsproxy