从零开始写 Docker(十六)---容器网络实现(上):为容器插上”网线”

Docker之网络配置 docker之网络配置 阅读详情

mydocker-network-1.png

本文为从零开始写 Docker 系列第十六篇,利用 linux 下的 Veth、Bridge、iptables 等等相关技术,构建容器网络模型,为容器插上”网线“。


完整代码见:https://github.com/lixd/mydocker
欢迎 Star

推荐阅读以下文章对 docker 基本实现有一个大致认识:


开发环境如下:

root@mydocker:~# lsb_release -a
No LSB modules are available.
Distributor ID:	Ubuntu
Description:	Ubuntu 20.04.2 LTS
Release:	20.04
Codename:	focal
root@mydocker:~# uname -r
5.4.0-74-generic

注意:需要使用 root 用户

1. 概述

前面文章中已经实现了容器的大部分功能,不过还缺少了网络部分。现在我们的容器既不能访问外网也不能访问其他容器。

本篇和下一篇文章则会解决该问题,会实现容器网络相关功能,为我们的容器插上”网线“。

本篇主要介绍大致思路以及 IPAM 和 Network Driver 组件的实现过程。

2. 网络模型

Docker 桥接网络

相关内容在这边文章:Docker教程(十)—揭秘 Docker 网络:手动实现 Docker 桥接网络 中已经有了详细记录,感兴趣的可以跳转阅读。

核心如下:

  • 首先容器就是一个进程,主要利用 Linux Namespace 进行隔离。
  • 那么,为了跨 Namespace 通信,就用到了 Veth pair。
  • 然后多个容器都使用 Veth pair 互相连通的话,不好管理,所以加入了 Linux Bridge,所有 veth 一端在容器中,一端直接和 bridge 连接,这样就好管理多了。
  • 最后容器和外部网络要进行通信,于是又要用到 iptables 的 NAT 规则进行地址转换。

接下来我们要做的就是使用 Go 代码实现这些功能。

设备抽象

首先,将 Bridge 和 Veth 这两个对象进行抽象:网络(Network)和网络端点(Endpoint)。

Network

网络(Netowrk)中可以有多个容器,在同一个网络里的容器可以通过这个网络互相通信。

就像挂载到同一个 Linux Bridge 设备上的网络设备一样, 可以直接通过 Bridge 设备实现网络互连;连接到同一个网络中的容器也可以通过这个网络和网络中别的容器互连。

网络中会包括这个网络相关的配置,比如网络的容器地址段、网络操作所调用的网络驱动等信息。

type Network struct {
    Name    string     // 网络名
    IPRange *net.IPNet // 地址段
    Driver  string     // 网络驱动名
}
Endpoint

网络端点(Endpoint)是用于连接容器与网络的,保证容器内部与网络的通信。

将 Linux 中的 veth-pair 一端挂载到容器内部,另一端挂载到 Bridge 上,就能打通容器和宿主机网络的通信。

网络端点中会包括连接到网络的一些信息,比如地址、Veth 设备、端口映射、连接的容器和网络等信息。

type Endpoint struct {
    ID          string           `json:"id"`
    Device      netlink.Veth     `json:"dev"`
    IPAddress   net.IP           `json:"ip"`
    MacAddress  net.HardwareAddr `json:"mac"`
    Network     *Network
    PortMapping []string
}

Network Driver

**网络驱动(Network Driver) **是一个网络功能中的组件,不同的驱动对网络的创建、连接、销毁的策略不同,通过在创建网络时指定不同的网络驱动来定义使用哪个驱动做网络的配置。

它的接口定义如下:

type Driver interface {
	Name() string
	Create(subnet string, name string) (*Network, error)
	Delete(name string) error
	Connect(network *Network, endpoint *Endpoint) error
	Disconnect(network Network, endpoint *Endpoint) error
}

IPAM

**IPAM(IP Address Management) **也是网络功能中的一个组件,用于网络 IP 地址的分配和释放,包括容器的IP地址和网络网关的IP地址,它的主要功能如下。

type IPAMer interface {
	Allocate(subnet *net.IPNet) (ip net.IP, err error) // 从指定的 subnet 网段中分配 IP 地址
	Release(subnet *net.IPNet, ipaddr *net.IP) error   //  从指定的 subnet 网段中释放掉指定的 IP 地址。
}

实现思路

为了给我们的容器插上网线,大致需要做以下工作:

  • 实现 IPAM ,完成对 IP 地址的管理
  • 实现 NetworkDriver,实现对网络的管理
  • 基于 IPAM 和 NetworkDriver 实现 mydocker network create/list/delete 命令, 让我们能通过 mydocker 命令实现对容器网络的管理
  • 实现 mydocker run -net,让容器可以加入指定网络

3. IPAM 实现

IPAM 主要管理 IP 的分配以及释放,因此需要找个地方存储哪些 IP 分配了,哪些 IP 可用。

由于对每个 IP 来说只存在已分配、可用两种状态,因此容器想到使用 bitmap 来存储。

bitmap

bitmap 在大规模连续且少状态的数据处理中有很高的效率,比如要用到的 IP 地址分配。

一个网段中的某个 IP 地址有两种状态:

  • 1 表示已经被分配了,
  • 0表示还未被分配;

那么一个 IP 地址的状态就可以用一位来表示, 并且通过这位相对基础位的偏移也能够迅速定位到数据所在的位。

通过位图的方式实现 IP 地址的管理也比较简单:

  • 分配 IP:在获取 IP 地址时,遍历每一项,找到值为 0 的项的偏移,然后通过偏移和网段的配置计算出分配的 IP 地址,并将该位置元素置为 1,表明 IP 地址已经被分配。
  • 释放 IP:根据 IP 和网段配置计算出偏移,然后将该位置元素置为 0,表示该 IP 地址可用。

数据结构定义

const ipamDefaultAllocatorPath = "/var/lib/mydocker/network/ipam/subnet.json"

type IPAM struct {
    SubnetAllocatorPath string             // 分配文件存放位置
    Subnets             *map[string]string // 网段和位图算法的数组 map, key 是网段, value 是分配的位图数组
}

// 初始化一个IPAM的对象,默认使用/var/lib/mydocker/network/ipam/subnet.json作为分配信息存储位置
var ipAllocator = &IPAM{
    SubnetAllocatorPath: ipamDefaultAllocatorPath,
}

整个定义比较简单,整个 IPAM 对象包括一个 SubnetAllocatorPath 字段用于存放数据的持久化位置,一个 Subnets 字段记录每一个网段中 IP 的分配情况。

注意:在这个定义中,为了代码实现简单和易于阅读,使用一个字符表示一个状态位,实际上可以采用一位表示一个是否分配的状态位,这样资源会有更低的消耗。

配置信息持久化

通过将分配信息序列化成 json 文件或将 json 文件以反序列化的方式保存和读取网段分配的信息到内存。

读取文件数据到内存:

// load 加载网段地址分配信息
func (ipam *IPAM) load() error {
	// 检查存储文件状态,如果不存在,则说明之前没有分配,则不需要加载
	if _, err := os.Stat(ipam.SubnetAllocatorPath); err != nil {
		if !os.IsNotExist(err) {
			return err
		}
		return nil
	}
	// 读取文件,加载配置信息
	subnetConfigFile, err := os.Open(ipam.SubnetAllocatorPath)
	if err != nil {
		return err
	}
	defer subnetConfigFile.Close()
	subnetJson := make([]byte, 2000)
	n, err := subnetConfigFile.Read(subnetJson)
	if err != nil {
		return errors.Wrap(err, "read subnet config file error")
	}
	err = json.Unmarshal(subnetJson[:n], ipam.Subnets)
	return errors.Wrap(err, "err dump allocation info")
}

将内存中的数据持久化到文件:

// dump 存储网段地址分配信息
func (ipam *IPAM) dump() error {
	ipamConfigFileDir, _ := path.Split(ipam.SubnetAllocatorPath)
	if _, err := os.Stat(ipamConfigFileDir); err != nil {
		if !os.IsNotExist(err) {
			return err
		}
		if err = os.MkdirAll(ipamConfigFileDir, constant.Perm0644); err != nil {
			return err
		}
	}
	// 打开存储文件 O_TRUNC 表示如果存在则消空, os O_CREATE 表示如果不存在则创建
	subnetConfigFile, err := os.OpenFile(ipam.SubnetAllocatorPath, os.O_TRUNC|os.O_WRONLY|os.O_CREATE, constant.Perm0644)
	if err != nil {
		return err
	}
	defer subnetConfigFile.Close()
	ipamConfigJson, err := json.Marshal(ipam.Subnets)
	if err != nil {
		return err
	}
	_, err = subnetConfigFile.Write(ipamConfigJson)
	return err
}

Allocate

这部分为 Allocate 方法的实现,比较简单

  • 1)从文件中加载 IPAM 数据

  • 2)根据子网信息在 map 中找到存储 IP 分配信息的字符串

  • 3)遍历字符串找到其中为 0 的元素,并根据偏移按照算法计算得到本次分配的 IP

  • 4)把对应位置置 1 并写回文件

// Allocate 在网段中分配一个可用的 IP 地址
func (ipam *IPAM) Allocate(subnet *net.IPNet) (ip net.IP, err error) {
	// 存放网段中地址分配信息的数组
	ipam.Subnets = &map[string]string{}

	// 从文件中加载已经分配的网段信息
	err = ipam.load()
	if err != nil {
		return nil, errors.Wrap(err, "load subnet allocation info error")
	}
	// net.IPNet.Mask.Size函数会返回网段的子网掩码的总长度和网段前面的固定位的长度
	// 比如“127.0.0.0/8”网段的子网掩码是“255.0.0.0”
	// 那么subnet.Mask.Size()的返回值就是前面255所对应的位数和总位数,即8和24
	_, subnet, _ = net.ParseCIDR(subnet.String())
	one, size := subnet.Mask.Size()
	// 如果之前没有分配过这个网段,则初始化网段的分配配置
	if _, exist := (*ipam.Subnets)[subnet.String()]; !exist {
		// /用“0”填满这个网段的配置,uint8(size - one )表示这个网段中有多少个可用地址
		// size - one是子网掩码后面的网络位数,2^(size - one)表示网段中的可用IP数
		// 而2^(size - one)等价于1 << uint8(size - one)
		// 左移一位就是扩大两倍

		(*ipam.Subnets)[subnet.String()] = strings.Repeat("0", 1<<uint8(size-one))
	}
	// 遍历网段的位图数组
	for c := range (*ipam.Subnets)[subnet.String()] {
		// 找到数组中为“0”的项和数组序号,即可以分配的 IP
		if (*ipam.Subnets)[subnet.String()][c] == '0' {
			// 设置这个为“0”的序号值为“1” 即标记这个IP已经分配过了
			// Go 的字符串,创建之后就不能修改 所以通过转换成 byte 数组,修改后再转换成字符串赋值
			ipalloc := []byte((*ipam.Subnets)[subnet.String()])
			ipalloc[c] = '1'
			(*ipam.Subnets)[subnet.String()] = string(ipalloc)
			// 这里的 subnet.IP只是初始IP,比如对于网段192 168.0.0/16 ,这里就是192.168.0.0
			ip = subnet.IP
			/*
				还需要通过网段的IP与上面的偏移相加计算出分配的IP地址,由于IP地址是uint的一个数组,
				需要通过数组中的每一项加所需要的值,比如网段是172.16.0.0/12,数组序号是65555,
				那么在[172,16,0,0] 上依次加[uint8(65555 >> 24)、uint8(65555 >> 16)、
				uint8(65555 >> 8)、uint8(65555 >> 0)], 即[0, 1, 0, 19], 那么获得的IP就
				是172.17.0.19.
			*/
			for t := uint(4); t > 0; t -= 1 {
				[]byte(ip)[4-t] += uint8(c >> ((t - 1) * 8))
			}
			// /由于此处IP是从1开始分配的(0被网关占了),所以最后再加1,最终得到分配的IP 172.17.0.20
			ip[3] += 1
			break
		}
	}
	// 最后调用dump将分配结果保存到文件中
	err = ipam.dump()
	if err != nil {
		log.Error("Allocate:dump ipam error", err)
	}
	return
}

Release

释放则和分配相反,根据 IP 计算出对应的位图数组索引位置并将其置 0,然后保存到文件中。

func (ipam *IPAM) Release(subnet *net.IPNet, ipaddr *net.IP) error {
	ipam.Subnets = &map[string]string{}
	_, subnet, _ = net.ParseCIDR(subnet.String())

	err := ipam.load()
	if err != nil {
		return errors.Wrap(err, "load subnet allocation info error")
	}
	// 和分配一样的算法,反过来根据IP找到位图数组中的对应索引位置
	c := 0
	releaseIP := ipaddr.To4()
	releaseIP[3] -= 1
	for t := uint(4); t > 0; t -= 1 {
		c += int(releaseIP[t-1]-subnet.IP[t-1]) << ((4 - t) * 8)
	}
	// 然后将对应位置0
	ipalloc := []byte((*ipam.Subnets)[subnet.String()])
	ipalloc[c] = '0'
	(*ipam.Subnets)[subnet.String()] = string(ipalloc)

	// 最后调用dump将分配结果保存到文件中
	err = ipam.dump()
	if err != nil {
		log.Error("Allocate:dump ipam error", err)
	}
	return nil
}

测试

通过两个单元测试来测试网段中 IP 的分配和释放。

func TestAllocate(t *testing.T) {
    _, ipNet, _ := net.ParseCIDR("192.168.0.1/24")
    ip, err := ipAllocator.Allocate(ipNet)
    if err != nil {
       t.Fatal(err)
    }
    t.Logf("alloc ip: %v", ip)
}

func TestRelease(t *testing.T) {
    ip, ipNet, _ := net.ParseCIDR("192.168.0.1/24")
    err := ipAllocator.Release(ipNet, &ip)
    if err != nil {
       t.Fatal(err)
    }
}
Allocate

先执行分配,看一下:

root@mydocker:~/feat-network-1/mydocker/network# go test -v -run TestAllocate
=== RUN   TestAllocate
    ipam_test.go:14: alloc ip: 192.168.0.1
--- PASS: TestAllocate (0.00s)
PASS
ok  	mydocker/network	0.006s

查看以下保存的文件是否正常:

root@mydocker:~/feat-network-1/mydocker/network# cat /var/lib/mydocker/network/ipam/subnet.json
{"192.168.0.0/24":"1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"}

可以看到网段的第 1 位被置为了 1,说明我们的分配功能是ok的。

Release

测试一下释放刚才分配的IP

root@mydocker:~/feat-network-1/mydocker/network# go test -v -run TestRelease
=== RUN   TestRelease
--- PASS: TestRelease (0.00s)
PASS
ok  	mydocker/network	0.005s

再次查看文件

root@mydocker:~/feat-network-1/mydocker/network# cat /var/lib/mydocker/network/ipam/subnet.json
{"192.168.0.0/24":"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"}

可以看到网段对应的第 1 位已经被重新置为 0 了,说明释放功能也是 ok 的。

4. NetworkDriver 实现

大致实现

这里实现简单的桥接网络作为容器的网络驱动,因此:

  • Create:创建 Bridge 设备
  • Delete:删除 Bridge 设备
  • Connect:将 veth 关联到网桥
  • Disconnect:将 veth 从网桥解绑

当然,除了 Bridge 设备外还有其他一些配置,,这篇文章Docker教程(十)—揭秘 Docker 网络:手动实现 Docker 桥接网络 有详细信息,这里就不在重复赘述。

文章中网络管理大致包括以下几条命令:

# 创建网桥
sudo brctl addbr br0
# 为bridge分配IP地址,激活上线
sudo ip addr add 172.18.0.1/24 dev br0
sudo ip link set br0 up
# 配置 nat 规则让容器可以访问外网
sudo iptables -t nat -A POSTROUTING -s 172.18.0.0/24 ! -o br0 -j MASQUERADE

我们的网络驱动要做的事情就是把上述命令用 Go 实现,需要用到以下几个库

  • net 库是 Go 语言内置的库,提供了跨平台支持的网络地址处理,以及各种常见协议的IO支持,比如TCP、UDP、DNS、Unix Socket等。
  • netlink库 是Go 语言的操作网络接口、路由表等配置的库 ,使用它的调用相当于我们通过 IP 命令去管理网络接口。
  • netns库 就是 Go 语言版的ip netns exec 命令实现。通过这个库可以让 netlink 库中配置网络接口的代码在某个容器的 Net amespace 中执行。

实现前面定义的 Driver 接口即可。

type BridgeNetworkDriver struct {
}

func (d *BridgeNetworkDriver) Name() string {
	return "bridge"
}

func (d *BridgeNetworkDriver) Create(subnet string, name string) (*Network, error) {
	return nil, err
}

// Delete 删除网络
func (d *BridgeNetworkDriver) Delete(network Network) error {
	return nil
}

func (d *BridgeNetworkDriver) Disconnect(network Network, endpoint *Endpoint) error {
	return nil
}

Create

根据子网信息创建 Bridge 设备并初始化。

func (d *BridgeNetworkDriver) Create(subnet string, name string) (*Network, error) {
    ip, ipRange, _ := net.ParseCIDR(subnet)
    ipRange.IP = ip
    n := &Network{
       Name:    name,
       IPRange: ipRange,
       Driver:  d.Name(),
    }
    err := d.initBridge(n)
    if err != nil {
       return nil, errors.Wrapf(err, "Failed to create bridge network")
    }
    return n, err
}

核心在 initBridge 中,具体如下:

func (d *BridgeNetworkDriver) initBridge(n *Network) error {
    bridgeName := n.Name
    // 1)创建 Bridge 虚拟设备
    if err := createBridgeInterface(bridgeName); err != nil {
       return errors.Wrapf(err, "Failed to create bridge %s", bridgeName)
    }

    // 2)设置 Bridge 设备地址和路由
    gatewayIP := *n.IPRange
    gatewayIP.IP = n.IPRange.IP

    if err := setInterfaceIP(bridgeName, gatewayIP.String()); err != nil {
       return errors.Wrapf(err, "Error set bridge ip: %s on bridge: %s", gatewayIP.String(), bridgeName)
    }
    // 3)启动 Bridge 设备
    if err := setInterfaceUP(bridgeName); err != nil {
       return errors.Wrapf(err, "Failed to set %s up", bridgeName)
    }

    // 4)设置 iptables SNAT 规则
    if err := setupIPTables(bridgeName, n.IPRange); err != nil {
       return errors.Wrapf(err, "Failed to set up iptables for %s", bridgeName)
    }

    return nil
}
创建 bridge 虚拟设备

这部分主要实现下面 ip link add x这个命令,创建一个 Bridge 设备。

// createBridgeInterface 创建Bridge设备
func createBridgeInterface(bridgeName string) error {
    // 先检查是否己经存在了这个同名的Bridge设备
    _, err := net.InterfaceByName(bridgeName)
    // 如果已经存在或者报错则返回创建错
    // errNoSuchInterface这个错误未导出也没提供判断方法,只能判断字符串了。。
    if err == nil || !strings.Contains(err.Error(), "no such network interface") {
       return err
    }

    // create *netlink.Bridge object
    la := netlink.NewLinkAttrs()
    la.Name = bridgeName
    // 使用刚才创建的Link的属性创netlink Bridge对象
    br := &netlink.Bridge{LinkAttrs: la}
    // 调用 net link Linkadd 方法,创 Bridge 虚拟网络设备
    // netlink.LinkAdd 方法是用来创建虚拟网络设备的,相当于 ip link add xxxx
    if err = netlink.LinkAdd(br); err != nil {
       return errors.Wrapf(err, "create bridge %s error", bridgeName)
    }
    return nil
}
设置 Bridge 设备的地址和路由

这部分主要实现下面 ip addr add xxx这个命令,为 Bridge 设备分为 IP 地址以及路由表配置。

func setInterfaceIP(name string, rawIP string) error {
   retries := 2
   var iface netlink.Link
   var err error
   for i := 0; i < retries; i++ {
      // 通过LinkByName方法找到需要设置的网络接口
      iface, err = netlink.LinkByName(name)
      if err == nil {
         break
      }
      log.Debugf("error retrieving new bridge netlink link [ %s ]... retrying", name)
      time.Sleep(2 * time.Second)
   }
   if err != nil {
      return errors.Wrap(err, "abandoning retrieving the new bridge link from netlink, Run [ ip link ] to troubleshoot")
   }
   // 由于 netlink.ParseIPNet 是对 net.ParseCIDR一个封装,因此可以将 net.PareCIDR中返回的IP进行整合
   // 返回值中的 ipNet 既包含了网段的信息,192 168.0.0/24 ,也包含了原始的IP 192.168.0.1
   ipNet, err := netlink.ParseIPNet(rawIP)
   if err != nil {
      return err
   }
   // 通过  netlink.AddrAdd给网络接口配置地址,相当于ip addr add xxx命令
   // 同时如果配置了地址所在网段的信息,例如 192.168.0.0/24
   // 还会配置路由表 192.168.0.0/24 转发到这 testbridge 的网络接口上
   addr := &netlink.Addr{IPNet: ipNet}
   return netlink.AddrAdd(iface, addr)
}
启动 Bridge 设备

这部分主要实现下面 ip link set xxx up这个命令,启动 Bridge 设备。

func setInterfaceUP(interfaceName string) error {
    link, err := netlink.LinkByName(interfaceName)
    if err != nil {
       return errors.Wrapf(err, "error retrieving a link named [ %s ]:", link.Attrs().Name)
    }
    // 等价于 ip link set xxx up 命令
    if err = netlink.LinkSetUp(link); err != nil {
       return errors.Wrapf(err, "nabling interface for %s", interfaceName)
    }
    return nil
}
设置 iptabels 规则

最后则是设置 iptables 规则实现 SNAT,便于容器访问外部网络。

$ iptables -t nat -A POSTROUTING -s 172.18.0.0/24 -o eth0 -j MASQUERADE
# 语法:iptables -t nat -A POSTROUTING -s {subnet} -o {deviceName} -j MASQUERADE
// setupIPTables 设置 iptables 对应 bridge MASQUERADE 规则
func setupIPTables(bridgeName string, subnet *net.IPNet) error {
    // 拼接命令
    iptablesCmd := fmt.Sprintf("-t nat -A POSTROUTING -s %s ! -o %s -j MASQUERADE", subnet.String(), bridgeName)
    cmd := exec.Command("iptables", strings.Split(iptablesCmd, " ")...)
    // 执行该命令
    output, err := cmd.Output()
    if err != nil {
       log.Errorf("iptables Output, %v", output)
    }
    return err
}

通过直接执行 iptables 命令,创建 SNAT 规则,只要是从这个网桥上出来的包,都会对其做源 IP 的转换,保证了容器经过宿主机访问到宿主机外部网络请求的包转换成机器的 IP,从而能正确的送达和接收。

Delete

删除就比较简单,删除对应名称的 Bridge 设备即可。

// Delete 删除网络
func (d *BridgeNetworkDriver) Delete(network Network) error {
    // 根据名字找到对应的Bridge设备
    br, err := netlink.LinkByName(network.Name)
    if err != nil {
       return err
    }
    // 删除网络对应的 Linux Bridge 设备
    return netlink.LinkDel(br)
}

Connect

connect 则是将 Endpoint 连接到当前指定网络。

类似于使用以下命令将 veth 设备添加到网桥设备上。

sudo brctl addif br0 veth1

实现如下:

// Connect 连接一个网络和网络端点
func (d *BridgeNetworkDriver) Connect(network *Network, endpoint *Endpoint) error {
	bridgeName := network.Name
	// 通过接口名获取到 Linux Bridge 接口的对象和接口属性
	br, err := netlink.LinkByName(bridgeName)
	if err != nil {
		return err
	}
	// 创建 Veth 接口的配置
	la := netlink.NewLinkAttrs()
	// 由于 Linux 接口名的限制,取 endpointID 的前
	la.Name = endpoint.ID[:5]
	// 通过设置 Veth 接口 master 属性,设置这个Veth的一端挂载到网络对应的 Linux Bridge
	la.MasterIndex = br.Attrs().Index
	// 创建 Veth 对象,通过 PeerNarne 配置 Veth 另外 端的接口名
	// 配置 Veth 另外 端的名字 cif {endpoint ID 的前 位}
	endpoint.Device = netlink.Veth{
		LinkAttrs: la,
		PeerName:  "cif-" + endpoint.ID[:5],
	}
	// 调用netlink的LinkAdd方法创建出这个Veth接口
	// 因为上面指定了link的MasterIndex是网络对应的Linux Bridge
	// 所以Veth的一端就已经挂载到了网络对应的LinuxBridge.上
	if err = netlink.LinkAdd(&endpoint.Device); err != nil {
		return fmt.Errorf("error Add Endpoint Device: %v", err)
	}
	// 调用netlink的LinkSetUp方法,设置Veth启动
	// 相当于ip link set xxx up命令
	if err = netlink.LinkSetUp(&endpoint.Device); err != nil {
		return fmt.Errorf("error Add Endpoint Device: %v", err)
	}
	return nil
}

Disconnct

Disconnect 就是把 veth 从 Bridge 上解绑,比较少用到,暂不实现。

func (d *BridgeNetworkDriver) Disconnect(network Network, endpoint *Endpoint) error {
	return nil
}

测试

同样先通过几个简单的单元测试来测试一下功能是否正常。

var testName = "testbridge"

func TestBridgeCreate(t *testing.T) {
	d := BridgeNetworkDriver{}
	n, err := d.Create("192.168.0.1/24", testName)
	if err != nil {
		t.Fatal(err)
	}
	t.Logf("create network :%v", n)
}

func TestBridgeDelete(t *testing.T) {
	d := BridgeNetworkDriver{}
	err := d.Delete(testName)
	if err != nil {
		t.Fatal(err)
	}
	t.Logf("delete network :%v", testName)
}

func TestBridgeConnect(t *testing.T) {
	ep := Endpoint{
		ID: "testcontainer",
	}

	n := Network{
		Name: testName,
	}

	d := BridgeNetworkDriver{}
	err := d.Connect(&n, &ep)
	if err != nil {
		t.Fatal(err)
	}
}

func TestBridgeDisconnect(t *testing.T) {
	ep := Endpoint{
		ID: "testcontainer",
	}

	n := Network{
		Name: testName,
	}

	d := BridgeNetworkDriver{}
	err := d.Disconnect(n, &ep)
	if err != nil {
		t.Fatal(err)
	}
}
Create
root@mydocker:~/feat-network-1/mydocker/network# go test -v -run TestBridgeCreate
=== RUN   TestBridgeCreate
    bridge_driver_test.go:15: create network :&{testbridge 192.168.0.1/24 bridge}
--- PASS: TestBridgeCreate (1.80s)
PASS
ok  	mydocker/network	1.804s

然后查看是否真正创建出了网桥

root@mydocker:~/feat-network-1/mydocker/network# ip link show
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
2: ens3: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP mode DEFAULT group default qlen 1000
    link/ether fa:16:3e:58:62:ef brd ff:ff:ff:ff:ff:ff
3: testbridge: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000
    link/ether b6:f9:fe:f3:f7:16 brd ff:ff:ff:ff:ff:ff

可以看到,第三个就是我们刚创建出的 testbridge 网桥,说明 create 是正常的。

Delete
root@mydocker:~/feat-network-1/mydocker/network# go test -v -run TestBridgeDelete
=== RUN   TestBridgeDelete
    bridge_driver_test.go:24: delete network :testbridge
--- PASS: TestBridgeDelete (0.02s)
PASS
ok  	mydocker/network	0.019s

检查是否真正删除了

root@mydocker:~/feat-network-1/mydocker/network# ip link show
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
2: ens3: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP mode DEFAULT group default qlen 1000
    link/ether fa:16:3e:58:62:ef brd ff:ff:ff:ff:ff:ff

testbridge 网桥已经不存在了,说明 Delete 也是正常的。

Connect

需要先创建网桥,在进行绑定测试:

root@mydocker:~/feat-network-1/mydocker/network# go test -v -run TestBridgeConnect
=== RUN   TestBridgeConnect
--- PASS: TestBridgeConnect (0.10s)
PASS
ok  	mydocker/network	0.104s

查看是否新建了 veth 并绑定到该网桥上了

root@mydocker:~/feat-network-1/mydocker/network# ip link show type veth
5: cif-testc@testc: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000
    link/ether 2a:fb:68:92:7e:59 brd ff:ff:ff:ff:ff:ff
6: testc@cif-testc: <NO-CARRIER,BROADCAST,MULTICAST,UP,M-DOWN> mtu 1500 qdisc noqueue master testbridge state LOWERLAYERDOWN mode DEFAULT group default qlen 1000
    link/ether 06:d6:04:62:13:eb brd ff:ff:ff:ff:ff:ff

可以看到,确实创建出了指定的 veth 设备(testc),由于只取了名称前 5 位,因此为 testc。

根据 master testbridge 属性可以知道,该 veth 关联到了前面创建的 testbridge 网桥上。

说明 Connect 方法是正常的。

Disconnect

需要先绑定后再测试解绑。

root@mydocker:~/feat-network-1/mydocker/network# go test -v -run TestBridgeDisconnect
=== RUN   TestBridgeDisconnect
--- PASS: TestBridgeDisconnect (0.01s)
PASS
ok  	mydocker/network	0.013s

查看是否接触绑定

root@mydocker:~/feat-network-1/mydocker/network# ip link show type veth
5: cif-testc@testc: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000
    link/ether 2a:fb:68:92:7e:59 brd ff:ff:ff:ff:ff:ff
6: testc@cif-testc: <NO-CARRIER,BROADCAST,MULTICAST,UP,M-DOWN> mtu 1500 qdisc noqueue state LOWERLAYERDOWN mode DEFAULT group default qlen 1000
    link/ether 06:d6:04:62:13:eb brd ff:ff:ff:ff:ff:ff

可以看到,之前的 master testbridge 属性不见了,说明解绑成功。

5. 小结

本章实现了容器网络的前置工作,包括:

  • 负载 IP 管理的 IPAM 组件
  • 以及网络管理的 NetworkDriver 组件。

下一篇会在此基础上,实现容器网络,包括:

  • mydocker network create/delete 命令,实现网络管理
  • mydocker run -net 参数,将容器加入到指定网络中

最后再次推荐一下 Docker教程(十)—揭秘 Docker 网络:手动实现 Docker 桥接网络


**【从零开始写 Docker 系列】**持续更新中,搜索公众号【探索云原生】订阅,阅读更多文章。



完整代码见:https://github.com/lixd/mydocker
欢迎关注~

相关代码见 feat-network-1 分支,测试脚本如下:

# 克隆代码
git clone -b feat-run-e https://github.com/lixd/mydocker.git
cd mydocker
# 进入 Network 目录
cd network
# 运行测试
go test -v -run TestAllocate
# 查看结果
cat /var/lib/mydocker/network/ipam/subnet.json
网络术语、接口与协议:Linux内核视角的实战解剖 网络术语不是抽象概念,而是可定位到内核结构体(如in_ifaddr)、抓包字段(如ip.src)和系统调用参数(如AF_INET)的技术实体;接口不仅是物理端口,更是net_device对象、veth虚拟对和ethtool可操作的MDIO寄存器;协议栈亦非黑盒,TCP分段、Modbus TCP报文格式、Ethernet/IP生产者模型等均需在Wireshark字节流与内核源码间双向验证。理解这些底层映射,才能真正排查LAN侧ARP广播异常、USB无线网卡驱动加载失败、OpenWRT多网段策略路由等高频工程问 阅读详情

相关推荐

数据包实战解析:从Wireshark抓包到TCP重传的网络排障核心

数据包是网络通信的基本传输单元,其本质是遵循IP/TCP协议规范的标准化数据封装体。它由应用层数据经传输层分段、网络层封装、链路层成帧逐级生成,携带源目的地址、端口、序列号、窗口大小、TTL、DF位等关键字段,支撑端到端可靠传输与路径控制。理解数据包结构与生命周期,对诊断丢包、MTU不匹配、防火墙拦截、容器网络不通等高频故障至关重要。本文结合Wireshark抓包分析、tcpdump实测与Linux内核行为,深入拆解HTTP请求的真实封装过程、TCP重传机制及云环境下的双重策略拦截逻辑,为运维、开发与安全工

devon2014的博客 407

dockerfile之CMD和ENDPOINT的区别

dockerfile的CMD和ENDPOINT的区别

weixin_58519482的博客 2907

基于行空板M10与Home Assistant打造全屋智能家居控制终端

智能家居的核心在于实现跨品牌、跨协议设备的统一管理与自动化联动。其技术原理通常围绕一个中央控制单元,通过Wi-Fi、蓝牙、Zigbee等通信协议连接各类终端设备,并借助自动化引擎实现场景联动。这一架构的技术价值在于打破生态壁垒,将控制权与数据本地化,从而提升系统响应速度、可靠性与隐私安全。典型的应用场景包括灯光、空调、安防等设备的集中控制与自动化场景。本文以行空板M10这一集成大屏与完整Linux系统的开发板作为硬件载体,详细阐述了如何将其与开源的Home Assistant平台深度结合,构建一个高度定制化

weixin_30340617的博客 515

从零开始写 Docker(一)---实现 mydocker run 命令

本文为从零开始写 Docker 系列第一篇,主要实现 mydocker run 命令,构造了一个具有基本的 Namespace 隔离的简单容器。

探索云原生 1008

树莓派5新手入门指南:从开箱到实战项目部署

微型计算机和嵌入式开发是物联网与智能硬件领域的核心技术基础,其核心在于通过小型化、低功耗的计算平台实现特定功能。树莓派作为代表性的单板计算机,通过集成处理器、内存和丰富接口,为开发者提供了接近通用计算机的体验,同时保持了硬件的可扩展性和成本优势。这种设计使得树莓派在智能家居、工业自动化、教育编程等领域具有极高的技术价值,尤其适合作为学习嵌入式系统、Linux操作系统和网络服务的入门平台。对于初学者而言,硬件设置和系统配置往往是首要挑战。树莓派5通过优化电源管理、预配置工具和散热设计,显著降低了入门门槛,其官

weixin_30781433的博客 395

玩客云刷Armbian:从矿渣到Linux服务器的完整改造指南

ARM架构作为嵌入式系统和低功耗设备的核心,其精简指令集和高效能特性使其在物联网、边缘计算等领域广泛应用。通过刷写第三方系统如Armbian,可以解锁设备的完整潜力,实现自定义服务部署。这一过程涉及Bootloader解锁、系统镜像烧录与底层驱动适配,技术价值在于将消费级硬件转化为低成本、高能效的Linux服务器。在智能家居、轻量级NAS、开发测试等场景中,此类改造能显著降低学习和部署门槛。本文以玩客云设备为例,结合Docker容器化技术和系统性能调优,详细演示了如何通过短接、刷机、服务部署等步骤,将闲置硬

weixin_30800987的博客 308

【Docker】Docker 网络

Docker是一个开源的应用容器引擎,它允许开发者将应用及其依赖打包到一个可移植的容器中,然后发布到任何流行的Linux机器或Windows机器上,也可以实现虚拟化。Docker的主要优势之一是其网络功能,而网络功能的核心就是网络驱动。

apple_csdn的博客 1043

【信息科学与工程学】【通信工程】第八十六篇 通信网络设备及通信网络组网的所有学科知识01

编号001类型网络虚拟化与覆盖技术网络领域数据中心网络子领域大二层网络 / 网络虚拟化核心数学方程式/算法模型核心算法:VXLAN封装与解封装。关键在于24位VNI(虚拟网络标识符)到物理网络的三层IP地址的映射。封装:收到原始以太帧后,为其添加 VXLAN 头部(含 VNI)、外层 UDP 头(目的端口 4789)、外层 IP 头(源 IP 为本地 VTEP IP,目的 IP 为对端 VTEP IP)以及外层 MAC 头。解封装:对端 收到报文后,剥离外层头部,根据内层帧的目的 MAC 和 VNI 进行二

weixin_49199313的博客 852

docker中cmd和endpoint

在docker制作镜像时,我们会创建Dockerfile文件并添加制作镜像的内容, 例如: FROM centos:7 ADD jdk-8u51-linux-x64.tar.gz /usr/local/docker ENV JAVA_HOME=/usr/local/docker/jdk1.8.0_51 PATH=/usr/local/docker/jdk1.8.0_51/bin:$PATH CMD [‘bash’] 或者 FROM centos:7 ADD jdk-8u51-linux-x64.tar.g

weixin_43488724的博客 3089

Python | 集合(set)运算之intersection()

简介 在做力扣题的时候,有一个思路是要求解两个字符串的交集。 一般来说,求解交集的思路是遍历两个字符串,判断有无相等,有相等则添加到交集中,直到循环结束。 但是这样做,会增加很多的不必要的遍历:比如说,当一个字符串中有多个相同的元素时,该元素会被遍历多次。 因此,在求解时,我们可以先将字符串转换为set集合类型。集合中存储的元素没有顺序,且互异(即元素不可重复)。 算例 求字符串m“abcdaaa” 与 字符串n“bcddses”是否存在交集 首先将字符串转换为set类型: m = set(m) n

lovetaozibaby的博客 1万+

Vitis HLS 学习指南与实践教程

Vitis HLS 学习指南与实践教程摘要:本文系统介绍了AMD Vitis HLS工具及其应用。HLS技术将C/C++代码自动转换为硬件描述语言,显著提升FPGA开发效率(5-10倍)。文章对比了HLS与传统RTL设计的优势,包括抽象级别高、开发周期短、代码重用性强等特点。详细讲解了Vitis HLS工具链的核心功能,包括支持的C/C++特性(如任意精度数据类型)、开发流程(项目创建-代码编写-仿真-综合)以及关键优化技术(流水线、循环展开、数组分割等编译指示)。通过具体代码示例展示了HLS设计方法,为F

weixin_44707118的博客 1401

docker Portainer

# docker Portainer ## 本机 ``` docker run -d -p 38089:9000 -v /var/run/docker.sock:/var/run/docker.sock --restart=always --name prtainer portainer/portainer ``` ## 远程 ``` docker run -d -p 38089:9000 --restart=always --name prtainer portainer/portainer `

一行真人 389

深度学习中 Internal Covariate Shift 问题以及 Batch Normalization 的作用

深度学习中 Internal Covariate Shift 问题以及 Batch Normalization 的作用前言一、Batch Normalization是什么?1.1 Internal Covariate Shift1.2 Internal Covariate Shift 带来的影响1.3 如何减缓 Internal Covariate Shift 问题带来的影响白化(Whitening)白化存在的问题二、Batch Normalization2.1 传统 Normalization2.2 改进

一扣解千愁的博客 4297

从零开始写 Docker(十九)---增加 cgroup v2 支持

合集 - Docker(27)1.深入理解 Docker 核心原理:Namespace、Cgroups 和 Rootfs2023-12-262.探索 Linux Namespace:Docker 隔离的神奇背后01-043.初探 Linux Cgroups:资源控制的奇妙世界01-094.深入剖析 Linux Cgroups 子系统:资源精细管理01-125.Docker 与 Linux Cgro...

weixin_40638343的博客 282

Android客户端如何设计架构

当我们在新开发一款APP时,我们在初期要如何设计架构呢?在这里我根据我的经验,总结了一些基本的架构思路。 客户端架构设计的时候,首先需要充分考虑到所开发的app的类型,这里我分为功能型和服务型两大类,功能型的app侧重业务和功能,服务型的app侧重服务和运算。下面我就具体来讲讲针对这两种类型的通用架构。 功能型app 功能型app的activity比较多,整个app都以一个个activity承载业务和功能,在设计这类app时,我们需要考虑哪些要素呢? 由于activity比较多,我们需要考虑页面的跳转路由,

子者不语的专栏 1544

程序进入hardfault之后查找原因的方法

如果在MCU运行程序的时候,进入了hardfault,该怎么办?

smart_boy__的博客 762

Docker最全教程之树莓派和Docker(十六)

前言树莓派(Raspberry Pi)是一台卡片电脑(只有信用卡大小),我们可以使用树莓派做很多事情,比如智能家居的中控、航空器、BT下载器、挖矿机、智能机器人、小型服务...

dotNET跨平台 517

在 Linux 64 位上遭遇 Signal 7 与 ST22 SYSTEM_CORE_DUMPED:从 es/implementation=std 到 /dev/shm 的一套落地排查法

摘要: Linux 64位SAP系统出现SYSTEM_CORE_DUMPED和Signal 7(对应SIGBUS)错误时,核心问题是进程因共享内存资源异常被操作系统强制终止。主要诱因包括:1)/dev/shm的tmpfs默认容量不足(通常仅占物理内存50%);2)SAP内存管理参数es/implementation=map在64位场景下的敏感性。解决方案应双管齐下:在实例profile设置es/implementation=std以降低对tmpfs的依赖,同时按(RAM+Swap)*75%重新配置/dev/

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 169

为大学生定制的2025年Ubuntu24.04安装过程,从安装Ubuntu到换源、更新、配置SSH和Docker的过程

本文为大学生提供Ubuntu 24.04详细安装指南,涵盖从ISO下载到系统配置的全过程。作者首先介绍了Ubuntu版本选择方法,推荐从清华镜像站下载LTS版本。安装步骤包括虚拟机设置、分区配置、账户创建等13个关键环节。系统配置部分重点讲解了换源、更新软件包、安装Docker和SSH服务,并通过创建Python容器实例验证环境可用性。全文采用分步式讲解,适合Linux初学者快速搭建开发环境。

2501_93631599的博客 1272

真正会做事的AI-OpenClaw关联飞书机器人

飞书关联Openclaw,实现AI高效办公

zy_xingdian的博客 220

【Matlab】飞行器气动弹性仿真与分析

气动弹性是飞行器设计领域的核心交叉学科,融合了空气动力学、结构动力学和控制理论,主要研究飞行器结构在气动力作用下的弹性变形、振动响应及相互耦合规律,直接影响飞行器的飞行稳定性、操纵性和结构安全性。随着飞行器向高速度、高机动性、轻量化方向发展,气动弹性问题愈发突出,如颤振、发散、嗡鸣等现象,严重时会导致飞行器结构破坏甚至飞行事故,因此气动弹性仿真与分析已成为飞行器设计、验证和优化的关键环节。当前,飞行器气动弹性仿真面临诸多技术挑战:气动力与结构变形的强耦合特性难以精准描述,易出现仿真误差;

unber的博客 239

服务器农场(Server Farm)技术全解析:架构、监控与自动化实践

服务器农场(Server Farm)是集中部署与统一管理大量服务器的基础设施形态,通过规模化解决单点故障和扩展瓶颈。其核心原理在于将计算、网络、存储与管理分层协同,配合监控与自动化体系实现集群的可靠运转。技术价值体现在高可用、水平扩展与运维效率提升,适用于流量波动大、业务连续性要求高的生产环境。从Docker Compose本地模拟迷你农场,到Prometheus告警配置与Ansible批量操作,工程实践能帮助团队低成本验证这套体系。当系统规模达到人力无法逐台维护时,服务器农场的监控、自动化与容量规划能力,

weixin_33901641的博客 301

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

自托管能源网关:Modbus TCP+Node.js+Docker工业边缘实践

自托管能源网关是面向工业现场的本地化数据中枢,本质是解决协议碎片化、云依赖与数据主权缺失问题。其核心原理基于协议翻译(尤其是Modbus TCP)、边缘实时计算与容器化部署,技术价值在于实现低延迟、高可靠、可审计的本地闭环控制。典型应用场景包括老旧电表接入、光伏防逆流调控、SCADA系统桥接及断网持续运行。本文聚焦Modbus TCP协议层陷阱、Node.js高精度轮询机制、Docker生产级加固策略三大关键技术支点,结合Kingscada、威纶通、汇川PLC等真实设备适配经验,提供可落地的能源数据流水线构

weixin_33994429的博客 419

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

云计算基础

云计算基础学习笔记

记录学习 1584

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

Linux netns+veth自环测试:无物理网卡快速验证网络性能

在Linux网络性能调优中,物理环境常受网卡驱动、交换机策略等因素干扰,难以定位瓶颈。网络命名空间(netns)与veth虚拟网卡组合提供了一种完全隔离的自环测试方案,无需物理硬件即可构建虚拟网络链路。其原理是通过创建两个独立的网络命名空间,用veth pair连接两端,数据流完整经过协议栈与虚拟驱动,更贴近容器通信模型。这种测试方法能有效校准内核协议栈基线性能、评估veth转发效率,并辅助TCP/UDP参数调优,常用于容器网络、OVS/DPDK虚拟化网络及内核网络栈排查场景。结合Iperf工具,可快速验证

weixin_34357887的博客 210

自托管能源网关:Modbus TCP工业现场稳定采集与Docker化交付实践

能源数据采集是工业物联网的基础环节,其核心在于可靠获取电表、PLC、触摸屏等异构设备的原始计量数据。Modbus TCP作为最广泛部署的工业协议,表面简单,实则面临地址偏移混乱、字节序不一、异常响应语义模糊、断网续传缺失等工程挑战。真正可用的解决方案需兼顾协议深度解析能力与边缘运行鲁棒性——这正是自托管能源网关的技术价值所在:它不依赖云服务,在本地完成协议适配、数据清洗、时间戳注入与多协议桥接,保障电费结算、能效审计等关键业务的数据主权与毫秒级可信度。本文聚焦Node.js与Docker在真实工业园区、光伏

weixin_34319817的博客 325
上一篇: 从零开始写 Docker(十五)---实现 mydocker run -e 支持环境变量传递
下一篇: 从零开始写 Docker(十七)---容器网络实现(中):为容器插上”网线“
探索云原生
博客等级 码龄9年 730粉丝 131原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值