..
声明：
本博客欢迎转发，但请保留原作者信息!
博客地址：http://blog.csdn.net/halcyonbaby
新浪微博：@寻觅神迹

内容系本人学习、研究和总结，如有雷同，实属荣幸！

Docker1.9后的network

介绍与使用

1.9之后，在Docker中network从实验特性转为正式特性发布。
从命令行可以看到新增如下命令：

[root@localhost system]# docker help network

Usage:  docker network [OPTIONS] COMMAND [OPTIONS]

Commands:
  create                   Create a network
  connect                  Connect container to a network
  disconnect               Disconnect container from a network
  inspect                  Display detailed network information
  ls                       List all networks
  rm                       Remove a network

Run ‘docker network COMMAND --help‘ for more information on a command.

  --help=false       Print usage

可以看到Docker daemon启动后默认创建了3个网络：
分别使用了bridge、null、host三种内置network driver。

[root@localhost system]# docker network ls
NETWORK ID          NAME                DRIVER
f280d6a13422        bridge              bridge
f5d11bed22a2        none                null
18642f53648f        host                host

我们来仔细看下三个网络的详细信息：
Name是network的名字，用户可以随意定义。
Id是network内部的uuid，全局唯一。
Scope目前有两个值“local”、“remote”，表示是本机网络还是多机网络。
Driver是指network driver的名字。
IPAM是负责IP管理发放的driver名字与配置信息（我们在bridge网络中可以看到该信息）。
Container内记录了使用这个网络的容器的信息。
Options内记录了driver所需的各种配置信息。

[root@localhost temp]# docker network inspect none
[
    {
        "Name": "none",
        "Id": "1abfa4750ada3be20927c3c168468f9a64efd10705d3be8958ae1eef784b28ef",
        "Scope": "local",
        "Driver": "null",
        "IPAM": {
            "Driver": "default",
            "Config": []
        },
        "Containers": {},
        "Options": {}
    }
]
[root@localhost temp]# docker network inspect host
[
    {
        "Name": "host",
        "Id": "001c9c9047d90efff0b64bf80e49ff7ec33421374b2c895169a0f9e096eb791d",
        "Scope": "local",
        "Driver": "host",
        "IPAM": {
            "Driver": "default",
            "Config": []
        },
        "Containers": {},
        "Options": {}
    }
]
[root@localhost temp]# docker network inspect bridge
[
    {
        "Name": "bridge",
        "Id": "201fbcb64b75977889f5d9c1e88c756308a090eb611397dbd0bb5c824d429276",
        "Scope": "local",
        "Driver": "bridge",
        "IPAM": {
            "Driver": "default",
            "Config": [
                {
                    "Subnet": "172.17.42.1/16",
                    "Gateway": "172.17.42.1"
                }
            ]
        },
        "Containers": {
            "4d4d37853115562080613393c6f605a9ec2b06c3660dfa0ca4e27f2da266773d": {
                "EndpointID": "09e332644c539cec8a9852a11d402893bc76a5559356817192657b5840fe2de3",
                "MacAddress": "02:42:ac:11:00:01",
                "IPv4Address": "172.17.0.1/16",
                "IPv6Address": ""
            }
        },

        "Options": {
            "com.docker.network.bridge.default_bridge": "true",
            "com.docker.network.bridge.enable_icc": "true",
            "com.docker.network.bridge.enable_ip_masquerade": "true",
            "com.docker.network.bridge.host_binding_ipv4": "0.0.0.0",
            "com.docker.network.bridge.name": "docker0",
            "com.docker.network.driver.mtu": "1500"
        }
    }
]

容器网络的各种操作：
-> 创建/添加/解除/删除网络

[root@localhost temp]# docker network create -d bridge --ip-range=192.168.1.0/24 --gateway=192.168.1.1 --subnet=192.168.1.0/24  bridge2
b18f4fb74ebd32b9f67631fd3fd842d09b97c30440efebe254a786d26811cf66
[root@localhost temp]# docker network ls
NETWORK ID          NAME                DRIVER
1abfa4750ada        none                null
001c9c9047d9        host                host
b18f4fb74ebd        bridge2             bridge
201fbcb64b75        bridge              bridge
[root@localhost temp]# docker exec vim ip addr
1: lo: 

driver plugin机制与driver plugin实现

简介

Docker插件一览：
http://docs.docker.com/engine/extend/plugins/
Docker的plugin采用了一种out-of-process的方式。
这样有两个好处，便于扩展、动态增加删除；同时代码上与Docker完全解耦。

Plugin是运行在Docker host上的一个进程，通过将一个文件放在plugin目录来向Docker注册，
从而被docker发现机制发现。

插件名字建议使用比较短的小写单词。插件可以在容器内或者容器外运行，建议在容器外。

插件目录

插件目录下可以放三种文件：

.sock files are UNIX domain sockets.
.spec files are text files containing a URL, such as unix:///other.sock.
.json files are text files containing a full json specification for the plugin.

.sock文件一般放置在/run/docker/plugins下；.spec/.json文件一般放置在/etc/docker/plugins
或者/usr/lib/docker/plugins下。

json文件范例：

{
  "Name": "plugin-example",
  "Addr": "https://example.com/docker/plugin",
  "TLSConfig": {
    "InsecureSkipVerify": false,
    "CAFile": "/usr/shared/docker/certs/example-ca.pem",
    "CertFile": "/usr/shared/docker/certs/example-cert.pem",
    "KeyFile": "/usr/shared/docker/certs/example-key.pem",
  }
}

插件的其他说明

Plugin需要在docker启动前启动；更新plugin时需要先停止docker daemon，更新后再启动docker daemon。

插件在第一次使用时激活。docker会根据指定的插件名字，在插件目录下查找。（感觉docker应该增加一个接口，查询本机插件列表）

Docker与plugin间使用，json格式基于Http的RPC消息，消息类型为post。

握手消息：

/Plugin.Activate
Request: empty body

Response:

{
    "Implements": ["VolumeDriver"]
}

Plugin实现

主要需要实现如下消息：

/Plugin.Activate
/NetworkDriver.GetCapabilities
/NetworkDriver.CreateNetwork
/NetworkDriver.DeleteNetwork
/NetworkDriver.CreateEndpoint
/NetworkDriver.EndpointOperInfo
/NetworkDriver.DeleteEndpoint
/NetworkDriver.Join
/NetworkDriver.Leave
/NetworkDriver.DiscoverNew 
/NetworkDriver.DiscoverDelete

详细参考:
https://github.com/docker/libnetwork/blob/master/docs/remote.md

libnetwork与docker

调用关系：

docker daemon—->libnetwork—–>network plugin

CNM介绍

https://github.com/docker/libnetwork/blob/master/docs/design.md
CNM全称Container Network Model。主要对libnetwork的网络模型进行了定义。

主要有三个概念：

• network
  一组可以直接互相通信的endpoint构成。通常的实现手段linux bridge/ovs等。
• sandbox
  sandbox包含了一个容器的网络栈。一般包含interface/route/dns设置等。一般通过namespace实现。
  一个sandbox可以包含多个属于不同network的endpoint。
• endpoint
  endpoint将一个sandbox与一个网络连通。
  通常可以使用linux bridge的veth pair或者ovs的internal port等技术。

CNM的主要对象有

• NetworkController
  主要负责管理driver，提供创建network接口。
• Driver
  提供network/sandbox/endpoint的实现。
• Network
• Endpoint
• Sandbox

代码分析

Docker daemon

• 在daemon初始化时创建了三个网络
  daemon.go 函数NewDaemon：

func NewDaemon(config *Config, registryService *registry.Service) (daemon *Daemon, err error) {
...
d.netController, err = d.initNetworkController(config)
    if err != nil {
        return nil, fmt.Errorf("Error initializing network controller: %v", err)
    }
...
}

• initNetworkController函数在daemon_unix.go/daemon_windows.go中，以unix为例：
  主要做了以下几件事情：
  初始化controller, 初始化null/host/bridge三个内置网络。

func (daemon *Daemon) initNetworkController(config *Config) (libnetwork.NetworkController, error) {
    netOptions, err := daemon.networkOptions(config)
    if err != nil {
        return nil, err
    }

    controller, err := libnetwork.New(netOptions...)
    if err != nil {
        return nil, fmt.Errorf("error obtaining controller instance: %v", err)
    }

    // Initialize default network on "null"
    if _, err := controller.NewNetwork("null", "none", libnetwork.NetworkOptionPersist(false)); err != nil {
        return nil, fmt.Errorf("Error creating default \"null\" network: %v", err)
    }

    // Initialize default network on "host"
    if _, err := controller.NewNetwork("host", "host", libnetwork.NetworkOptionPersist(false)); err != nil {
        return nil, fmt.Errorf("Error creating default \"host\" network: %v", err)
    }

    if !config.DisableBridge {
        // Initialize default driver "bridge"
        if err := initBridgeDriver(controller, config); err != nil {
            return nil, err
        }
    }

    return controller, nil
}

• 启动容器时创建网络

api/server/router/container/container.go
local.NewPostRoute("/containers/{name:.*}/start", r.postContainersStart),
postContainersStart中调用了containerStart函数
daemon/start.go
func (daemon *Daemon) containerStart(container *Container) (err error) {
    ...
    if err := daemon.initializeNetworking(container); err != nil {
        return err
    }
        ...
}
daemon/container_unix.go
func (daemon *Daemon) initializeNetworking(container *Container) error {
...
    if err := daemon.allocateNetwork(container); err != nil {
        return err
    }
...
}
func (daemon *Daemon) allocateNetwork(container *Container) error {
...
    for n := range container.NetworkSettings.Networks {
        if err := daemon.connectToNetwork(container, n, updateSettings); err != nil {
            return err
        }
    }
...
}
func (daemon *Daemon) connectToNetwork(container *Container, idOrName string, updateSettings bool) (err error) {
...
// 创建endpoint
ep, err = n.CreateEndpoint(endpointName, createOptions...)
...
// 获得sandbox
sb := daemon.getNetworkSandbox(container)
...
// 接入sandbox
    if err := ep.Join(sb); err != nil {
        return err
    }
...
}

• 创建Network
  实际上是调用libnetwork的NewNetwork接口。
  network的所有API，都会被路由到daemon/network.go中的函数上

daemon/network.go
// CreateNetwork creates a network with the given name, driver and other optional parameters
func (daemon *Daemon) CreateNetwork(name, driver string, ipam network.IPAM, options map[string]string) (libnetwork.Network, error) {
    c := daemon.netController
    if driver == "" {
        driver = c.Config().Daemon.DefaultDriver
    }

    nwOptions := []libnetwork.NetworkOption{}

    v4Conf, v6Conf, err := getIpamConfig(ipam.Config)
    if err != nil {
        return nil, err
    }

    nwOptions = append(nwOptions, libnetwork.NetworkOptionIpam(ipam.Driver, "", v4Conf, v6Conf))
    nwOptions = append(nwOptions, libnetwork.NetworkOptionDriverOpts(options))
    return c.NewNetwork(driver, name, nwOptions...)
}

• Connect容器到Network
  我们再看看connect容器到Network。
  可以看到最后也是调用了libnetwork的接口。
  创建EP，加入sandbox。

// ConnectContainerToNetwork connects the given container to the given
// network. If either cannot be found, an err is returned. If the
// network cannot be set up, an err is returned.
func (daemon *Daemon) ConnectContainerToNetwork(containerName, networkName string) error {
    container, err := daemon.Get(containerName)
    if err != nil {
        return err
    }
    return daemon.ConnectToNetwork(container, networkName)
}
// ConnectToNetwork connects a container to a network
func (daemon *Daemon) ConnectToNetwork(container *Container, idOrName string) error {
    if !container.Running {
        return derr.ErrorCodeNotRunning.WithArgs(container.ID)
    }
    if err := daemon.connectToNetwork(container, idOrName, true); err != nil {
        return err
    }
    if err := container.toDiskLocking(); err != nil {
        return fmt.Errorf("Error saving container to disk: %v", err)
    }
    return nil
}
func (daemon *Daemon) connectToNetwork(container *Container, idOrName string, updateSettings bool) (err error) {
    if container.hostConfig.NetworkMode.IsContainer() {
        return runconfig.ErrConflictSharedNetwork
    }

    if runconfig.NetworkMode(idOrName).IsBridge() &&
        daemon.configStore.DisableBridge {
        container.Config.NetworkDisabled = true
        return nil
    }

    controller := daemon.netController

    n, err := daemon.FindNetwork(idOrName)
    if err != nil {
        return err
    }

    if updateSettings {
        if err := daemon.updateNetworkSettings(container, n); err != nil {
            return err
        }
    }

    ep, err := container.getEndpointInNetwork(n)
    if err == nil {
        return fmt.Errorf("container already connected to network %s", idOrName)
    }

    if _, ok := err.(libnetwork.ErrNoSuchEndpoint); !ok {
        return err
    }

    createOptions, err := container.buildCreateEndpointOptions(n)
    if err != nil {
        return err
    }

    endpointName := strings.TrimPrefix(container.Name, "/")
    ep, err = n.CreateEndpoint(endpointName, createOptions...)
    if err != nil {
        return err
    }
    defer func() {
        if err != nil {
            if e := ep.Delete(); e != nil {
                logrus.Warnf("Could not rollback container connection to network %s", idOrName)
            }
        }
    }()

    if err := daemon.updateEndpointNetworkSettings(container, n, ep); err != nil {
        return err
    }

    sb := daemon.getNetworkSandbox(container)
    if sb == nil {
        options, err := daemon.buildSandboxOptions(container, n)
        if err != nil {
            return err
        }
        sb, err = controller.NewSandbox(container.ID, options...)
        if err != nil {
            return err
        }

        container.updateSandboxNetworkSettings(sb)
    }

    if err := ep.Join(sb); err != nil {
        return err
    }

    if err := container.updateJoinInfo(n, ep); err != nil {
        return derr.ErrorCodeJoinInfo.WithArgs(err)
    }

    return nil
}

其他功能和上述分析类似。

libnetwork

Libnetwork代码中内置了若干个driver,分别是（bridge,null,host,overlay,remote,windows)，其中bridge,null,host是常用的local driver。
overlay是docker新发布的multi-host network方案。remote则可以与第三方定制的driver plugin通信。
参考libnetwork/dirvers/remote/driver.go的函数，最后是发送rest消息与plugin通信。

...
func (d *driver) CreateNetwork(id string, options map[string]interface{}, ipV4Data, ipV6Data []driverapi.IPAMData) error {
    create := &api.CreateNetworkRequest{
        NetworkID: id,
        Options:   options,
        IPv4Data:  ipV4Data,
        IPv6Data:  ipV6Data,
    }
    return d.call("CreateNetwork", create, &api.CreateNetworkResponse{})
}

func (d *driver) DeleteNetwork(nid string) error {
    delete := &api.DeleteNetworkRequest{NetworkID: nid}
    return d.call("DeleteNetwork", delete, &api.DeleteNetworkResponse{})
}
...