深入解析docker内核网桥

今天做虚拟桌面,朋友问我,为什么vnc 连接另一个docker 容器一直超时,原因是在docker 启动的时候没有组网,那么接下来我就要解析下docker的内核网络。

我们思考几个问题,带你了解linux 中docker 网络实现的基本原理。

文章分析的基石来源于 Docker 的moby源码:

https://github.com/moby/moby

一、docker 网络组成

深入解析docker内核网桥_第1张图片docker 默认有主机模式和网桥模式,这里只说网桥模式,我们说一下docker内核的网桥代码

先简单说一下容器,容器底层调用的是linux 的 clone,我们使用clone的时候有一些独特的标志位

CLONE_NEWNES,

CLONE_NEWUTS,

CLONE_NEWIPC,

CLONE_NEWPID,

CLONE_NEWNET 

使用linux内核的这些标志位,我们都可以创建出不同NS的进程,其中我们需要注意的是CLONE_NEWNET 

二、Docker 桥接模式分析

Docker Bridge 实现方式如下:

1)我们实现要考虑不同的两个进程 netns 是不一样的,那么这两个不同的netns之间如何通信?

我们可以使用linux 的 veth 接口 ,申请两个veth 设备假设是veth0 和 veth1。而veth pair 设备确保无论哪一个收到报文都会发送给另一端

2)我们把veth0 附加到 docker daemon 创建的docker0 网桥上。保证宿主机有能力把报文发送到veth0

3) 然后我们把 veth1 添加到容器所属的命名空间下,veth1 在Docker 容器里看来就是eth0。一方面保证网络报文发往veth0,可以被veth1收到,实现宿主机到docker 容器之间连通性。

1)问题反思?

docker 网桥是如何实现的?

docker 又是怎么通过建立linux 设备veth的?

docker 创建这些基础网络组件的过程中,到底是用了linux 内核的哪些特性?

2)docker 网桥是如何实现的?

go 部分

我们翻阅Docker 源码,发现这么一段

位于源码的

 daemon/daemon_unix.go

	// --ip processing
	if cfg.DefaultIP != nil {
		netOption[bridge.DefaultBindingIP] = cfg.DefaultIP.String()
	}

_, err = controller.NewNetwork("bridge", "bridge", "",
		libnetwork.NetworkOptionEnableIPv6(cfg.EnableIPv6),
		libnetwork.NetworkOptionDriverOpts(netOption),
		libnetwork.NetworkOptionIpam("default", "", v4Conf, v6Conf, nil),
		libnetwork.NetworkOptionDeferIPv6Alloc(deferIPv6Alloc))

libnetwork/controller.go 

func (c *Controller) addNetwork(n *Network) error {
	d, err := n.driver(true)
	if err != nil {
		return err
	}

	// Create the network
	if err := d.CreateNetwork(n.id, n.generic, n, n.getIPData(4), n.getIPData(6)); err != nil {
		return err
	}

	n.startResolver()

	return nil
}

最后我们发现网桥的实现最后到了CreateNetwork中,我们在追踪进入CreateNetwork中

libnetwork/drivers/bridge/bridge_linux.go 

CreateNetwork 的实现我们发现具体关键代码位于

	// If the bridge interface doesn't exist, we need to start the setup steps
	// by creating a new device and assigning it an IPv4 address.
	bridgeAlreadyExists := bridgeIface.exists()
	if !bridgeAlreadyExists {
		bridgeSetup.queueStep(setupDevice)
		bridgeSetup.queueStep(setupDefaultSysctl)
	}

再继续看 setupDevice,一切水落石处,Docker 网桥创建的关键在于 setupDevice

func setupDevice(config *networkConfiguration, i *bridgeInterface) error {
	// We only attempt to create the bridge when the requested device name is
	// the default one. The default bridge name can be overridden with the
	// DOCKER_TEST_CREATE_DEFAULT_BRIDGE env var. It should be used only for
	// test purpose.
	var defaultBridgeName string
	if defaultBridgeName = os.Getenv("DOCKER_TEST_CREATE_DEFAULT_BRIDGE"); defaultBridgeName == "" {
		defaultBridgeName = DefaultBridgeName
	}
	if config.BridgeName != defaultBridgeName && config.DefaultBridge {
		return NonDefaultBridgeExistError(config.BridgeName)
	}

	// Set the bridgeInterface netlink.Bridge.
	i.Link = &netlink.Bridge{
		LinkAttrs: netlink.LinkAttrs{
			Name: config.BridgeName,
		},
	}

	// Set the bridge's MAC address. Requires kernel version 3.3 or up.
	hwAddr := netutils.GenerateRandomMAC()
	i.Link.Attrs().HardwareAddr = hwAddr
	log.G(context.TODO()).Debugf("Setting bridge mac address to %s", hwAddr)

	if err := i.nlh.LinkAdd(i.Link); err != nil {
		log.G(context.TODO()).WithError(err).Errorf("Failed to create bridge %s via netlink", config.BridgeName)
		return err
	}

	return nil
}
linux 接口部分:

既然我们找到了库的实现,那么我们继续思考netlink库为什么能调在linux 系统里创建网桥,它到底是使用了kernel 开发的哪些能力?

分析go netlink 库我发现了一个函数叫linkModify,他的一段代码实现如下:

	_, err := req.Execute(unix.NETLINK_ROUTE, 0)
	if err != nil {
		return err
	}

底层使用的是 

func getNetlinkSocket(protocol int) (*NetlinkSocket, error) {
	fd, err := unix.Socket(unix.AF_NETLINK, unix.SOCK_RAW|unix.SOCK_CLOEXEC, protocol)
	if err != nil {
		return nil, err
	}
	s := &NetlinkSocket{
		fd: int32(fd),
	}
	s.lsa.Family = unix.AF_NETLINK
	if err := unix.Bind(fd, &s.lsa); err != nil {
		unix.Close(fd)
		return nil, err
	}

	return s, nil
}

也就是说Docker 的网络库最终使用的是

netlink socket API:
 socket()函数
        socket域(地址族)是AF_NETLINK
        socket类型是SOCK_RAW或SOCK_DGRAM,因为netlink是一种面向数据的服务
        netlink协议类型定义在netlink.h(以下以NETLINK_ROUTE为例),也可以自定义
AF_NETLINK 无疑是linux 中内核态和用户态通信的重要手段,他和ioctl的最大区别是,AF_NETLINK是一种协议族,提供了一种标准化的机制,用于用户态程序与内核之间进行网络相关的通信。它定义了不同的协议类型,如NETLINK_ROUTENETLINK_SELINUX等,以支持特定的网络操作和功能。使用AF_NETLINK,用户态程序可以发送特定类型的消息给内核,以请求或传递网络相关的信息。

docker 是使用AF_NETLINK 做的,而我们使用brctl 却是使用的ioctl

docker veth 设备是如何实现的

case *Veth:
		data := linkInfo.AddRtAttr(nl.IFLA_INFO_DATA, nil)
		peer := data.AddRtAttr(nl.VETH_INFO_PEER, nil)
		nl.NewIfInfomsgChild(peer, unix.AF_UNSPEC)
		peer.AddRtAttr(unix.IFLA_IFNAME, nl.ZeroTerminated(link.PeerName))
		if base.TxQLen >= 0 {
			peer.AddRtAttr(unix.IFLA_TXQLEN, nl.Uint32Attr(uint32(base.TxQLen)))
		}
		if base.NumTxQueues > 0 {
			peer.AddRtAttr(unix.IFLA_NUM_TX_QUEUES, nl.Uint32Attr(uint32(base.NumTxQueues)))
		}
		if base.NumRxQueues > 0 {
			peer.AddRtAttr(unix.IFLA_NUM_RX_QUEUES, nl.Uint32Attr(uint32(base.NumRxQueues)))
		}
		if base.MTU > 0 {
			peer.AddRtAttr(unix.IFLA_MTU, nl.Uint32Attr(uint32(base.MTU)))
		}
		if link.PeerHardwareAddr != nil {
			peer.AddRtAttr(unix.IFLA_ADDRESS, []byte(link.PeerHardwareAddr))
		}
		if link.PeerNamespace != nil {
			switch ns := link.PeerNamespace.(type) {
			case NsPid:
				val := nl.Uint32Attr(uint32(ns))
				peer.AddRtAttr(unix.IFLA_NET_NS_PID, val)
			case NsFd:
				val := nl.Uint32Attr(uint32(ns))
				peer.AddRtAttr(unix.IFLA_NET_NS_FD, val)
			}
		}

我们发现还是AF_NETLINK 实现的

三、快速组网组成一个测试网络

创建网桥

ip link add br0 type bridge

启动网桥

ip link set br0 up

创建网络命名空间ns1 和ns2 

~# ip netns add ns1
~# ip netns add ns2

 创建 veth 对

~# ip link add veth0 type veth peer br-veth0
~# ip link add veth1 type veth peer br-veth1

查看创建的 veth 对,通过查看此时 veth对 在 root名称空间下

ip address show

将创建的 veth对 的一端插入到指定的名称空间 

~# ip link set veth0 netns ns1
~# ip link set veth1 netns ns2

通过进入不同的名称空间查看网卡的一端

~# ip netns exec ns1 ip a
~# ip netns exec ns2 ip a

将创建的 veth对 的另一端插入到 br0 的桥接网卡

~# ip link set br-veth0 master br0
~# ip link set br-veth1 master br0

 启动网卡 veth0 veth1 br-veth0 br-veth1,并配置 ip 地址

// 开启网桥部分
~# ip link set br-veth0 up
~# ip link set br-veth1 up

// 开启ns里的veth
~# ip netns exec ns1 ip link set veth0 up
~# ip netns exec ns2 ip link set veth1 up

// 设置容器内的veth 设备ip
~# ip netns exec ns1 ifconfig veth0 192.168.100.10/24
~# ip netns exec ns2 ifconfig veth1 192.168.100.20/24

四、总结

Docker 创建网桥和Veth设备都是通过AF_NETLINK 套接字实现的,我需要去读 <精通linux内核网络>这本书去调研一下

你可能感兴趣的:(docker,容器,运维)