0.前言

首先要知道一个运行的容器，其实就是一个受到隔离和资源限制的Linux进程——对，它就是一个进程。而本文主要来探讨Docker容器实现隔离用到的技术Linux Namespace。

1.关于 Linux Namespace

Linux提供如下Namespace:

Namespace   Constant          IsolatesCgroup      CLONE_NEWCGROUP   Cgroup root directoryIPC         CLONE_NEWIPC      System V IPC, POSIX message queuesNetwork     CLONE_NEWNET      Network devices, stacks, ports, etc.Mount       CLONE_NEWNS       Mount pointsPID         CLONE_NEWPID      Process IDsUser        CLONE_NEWUSER     User and group IDsUTS         CLONE_NEWUTS      Hostname and NIS domain name

以上Namespace分别对进程的 Cgroup root、进程间通信、网络、文件系统挂载点、进程ID、用户和组、主机名域名等进行隔离。

创建容器（进程）主要用到三个系统调用：

clone() – 实现线程的系统调用，用来创建一个新的进程，并可以通过上述参数达到隔离

unshare() – 使某进程脱离某个namespace

setns() – 把某进程加入到某个namespace

2.举个例子（PID namespace）

1) 启动一个容器

$ docker run -it busybox /bin/sh/ #

2) 查看容器中的进程id(可以看到/bin/sh的pid=1)

/ # psPID   USER     TIME  COMMAND    1 root      0:00 /bin/sh    5 root      0:00 ps

3) 查看宿主机中的该/bin/sh的进程id

# ps -ef |grep busyroot      3702  3680  0 15:53 pts/0    00:00:00 docker run -it busybox /bin/sh

可以看到，我们在Docker里最开始执行的/bin/sh，就是这个容器内部的第1号进程（PID=1），而在宿主机上看到它的PID=3702。这就意味着，前面执行的/bin/sh，已经被Docker隔离在了一个跟宿主机完全不同的世界当中。

而这就是Docker在启动一个容器（创建一个进程）时使用了PID namespace

int pid = clone(main_function, stack_size, CLONE_NEWPID | SIGCHLD, NULL);

这时候，Docker就会在这个PID=3702的进程启动时给他施一个“障眼法”，让他永远看不到不属于它这个namespace中的进程。这种机制，其实就是对被隔离应用的进程空间做了手脚，使得这些进程只能看到重新计算过的进程编号，比如PID=1。可实际上，他们在宿主机的操作系统里，还是原来的第3702号进程。

然后如果你自己只用PID namespace使用上述的clone()创建一个进程，查看ps或top等命令时，却还是能看到所有进程。说明并没有完全隔离，这是因为，像ps、top这些命令会去读/proc文件系统，而此时你创建的隔离了pid的进程和宿主机使用的是同一个/proc文件系统，所以这些命令显示的东西都是一样的。所以，我们还需要使其它的namespace隔离，如文件系统进行隔离。

3.对照Docker源码

当启动一个docker容器时，会调用到dockerd提供的/containers/{name:.*}/start接口，然后启动一个容器，docker服务收到请求后，调用关系如下：

//注册http handlerrouter.NewPostRoute("/containers/{name:.*}/start", r.postContainersStart)//func (s *containerRouter) postContainersStart(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error //func (daemon *Daemon) ContainerStart(name string, hostConfig *containertypes.HostConfig, checkpoint string, checkpointDir string) error //func (daemon *Daemon) containerStart(container *container.Container, checkpoint string, checkpointDir string, resetRestartManager bool) (err error) {    //...    spec, err := daemon.createSpec(container)	//...    err = daemon.containerd.Create(context.Background(), container.ID, spec, createOptions)	//...	pid, err := daemon.containerd.Start(context.Background(), container.ID, checkpointDir,		container.StreamConfig.Stdin() != nil || container.Config.Tty,		container.InitializeStdio)	//...	container.SetRunning(pid, true)	//...}

可以看到在Daemon.containerStart接口中创建并启动了容器，而创建容器时传入的spec参数就包含了namespace，我们再来看看daemon.createSpec(container)接口返回的spec是什么：

func (daemon *Daemon) createSpec(c *container.Container) (retSpec *specs.Spec, err error) {    s := oci.DefaultSpec()    //...    if err := setUser(&s, c); err != nil {		return nil, fmt.Errorf("linux spec user: %v", err)	}	if err := setNamespaces(daemon, &s, c); err != nil {		return nil, fmt.Errorf("linux spec namespaces: %v", err)	}	//...	return &s}//oci.DefaultSpec()会调用DefaultLinuxSpec,可以看到返回的spec中包含了namespacefunc DefaultLinuxSpec() specs.Spec {    s := specs.Spec{		Version: specs.Version,		Process: &specs.Process{			Capabilities: &specs.LinuxCapabilities{				Bounding:    defaultCapabilities(),				Permitted:   defaultCapabilities(),				Inheritable: defaultCapabilities(),				Effective:   defaultCapabilities(),			},		},		Root: &specs.Root{},	}	s.Mounts = []specs.Mount{		{			Destination: "/proc",			Type:        "proc",			Source:      "proc",			Options:     []string{"nosuid", "noexec", "nodev"},		},		{			Destination: "/sys/fs/cgroup",			Type:        "cgroup",			Source:      "cgroup",			Options:     []string{"ro", "nosuid", "noexec", "nodev"},		},		//...	}	s.Linux = &specs.Linux{	    //...		Namespaces: []specs.LinuxNamespace{			{Type: "mount"},			{Type: "network"},			{Type: "uts"},			{Type: "pid"},			{Type: "ipc"},		},		//...	//...	return s}//而在setNamespaces中还会根据其它配置对namespace进行修改func setNamespaces(daemon *Daemon, s *specs.Spec, c *container.Container) error {	userNS := false	// user	if c.HostConfig.UsernsMode.IsPrivate() {		uidMap := daemon.idMapping.UIDs()		if uidMap != nil {			userNS = true			ns := specs.LinuxNamespace{Type: "user"}			setNamespace(s, ns)			s.Linux.UIDMappings = specMapping(uidMap)			s.Linux.GIDMappings = specMapping(daemon.idMapping.GIDs())		}	}	// network	if !c.Config.NetworkDisabled {		ns := specs.LinuxNamespace{Type: "network"}		parts := strings.SplitN(string(c.HostConfig.NetworkMode), ":", 2)		if parts[0] == "container" {			nc, err := daemon.getNetworkedContainer(c.ID, c.HostConfig.NetworkMode.ConnectedContainer())			if err != nil {				return err			}			ns.Path = fmt.Sprintf("/proc/%d/ns/net", nc.State.GetPID())			if userNS {				// to share a net namespace, they must also share a user namespace				nsUser := specs.LinuxNamespace{Type: "user"}				nsUser.Path = fmt.Sprintf("/proc/%d/ns/user", nc.State.GetPID())				setNamespace(s, nsUser)			}		} else if c.HostConfig.NetworkMode.IsHost() {			ns.Path = c.NetworkSettings.SandboxKey		}		setNamespace(s, ns)	}	// ipc	ipcMode := c.HostConfig.IpcMode	switch {	case ipcMode.IsContainer():		ns := specs.LinuxNamespace{Type: "ipc"}		ic, err := daemon.getIpcContainer(ipcMode.Container())		if err != nil {			return err		}		ns.Path = fmt.Sprintf("/proc/%d/ns/ipc", ic.State.GetPID())		setNamespace(s, ns)		if userNS {			// to share an IPC namespace, they must also share a user namespace			nsUser := specs.LinuxNamespace{Type: "user"}			nsUser.Path = fmt.Sprintf("/proc/%d/ns/user", ic.State.GetPID())			setNamespace(s, nsUser)		}	case ipcMode.IsHost():		oci.RemoveNamespace(s, specs.LinuxNamespaceType("ipc"))	case ipcMode.IsEmpty():		// A container was created by an older version of the daemon.		// The default behavior used to be what is now called "shareable".		fallthrough	case ipcMode.IsPrivate(), ipcMode.IsShareable(), ipcMode.IsNone():		ns := specs.LinuxNamespace{Type: "ipc"}		setNamespace(s, ns)	default:		return fmt.Errorf("Invalid IPC mode: %v", ipcMode)	}	// pid	if c.HostConfig.PidMode.IsContainer() {		ns := specs.LinuxNamespace{Type: "pid"}		pc, err := daemon.getPidContainer(c)		if err != nil {			return err		}		ns.Path = fmt.Sprintf("/proc/%d/ns/pid", pc.State.GetPID())		setNamespace(s, ns)		if userNS {			// to share a PID namespace, they must also share a user namespace			nsUser := specs.LinuxNamespace{Type: "user"}			nsUser.Path = fmt.Sprintf("/proc/%d/ns/user", pc.State.GetPID())			setNamespace(s, nsUser)		}	} else if c.HostConfig.PidMode.IsHost() {		oci.RemoveNamespace(s, specs.LinuxNamespaceType("pid"))	} else {		ns := specs.LinuxNamespace{Type: "pid"}		setNamespace(s, ns)	}	// uts	if c.HostConfig.UTSMode.IsHost() {		oci.RemoveNamespace(s, specs.LinuxNamespaceType("uts"))		s.Hostname = ""	}	return nil}func setNamespace(s *specs.Spec, ns specs.LinuxNamespace) {	for i, n := range s.Linux.Namespaces {		if n.Type == ns.Type {			s.Linux.Namespaces[i] = ns			return		}	}	s.Linux.Namespaces = append(s.Linux.Namespaces, ns)}

其实很早以前Docker创建一个容器，获取namespace是通过CloneFlags函数，后来有了开放容器计划(OCI)规范后，就改为了以上面代码中方式创建容器。OCI之前代码如下：

var namespaceInfo = map[NamespaceType]int{	NEWNET:  unix.CLONE_NEWNET,	NEWNS:   unix.CLONE_NEWNS,	NEWUSER: unix.CLONE_NEWUSER,	NEWIPC:  unix.CLONE_NEWIPC,	NEWUTS:  unix.CLONE_NEWUTS,	NEWPID:  unix.CLONE_NEWPID,}// CloneFlags parses the container's Namespaces options to set the correct// flags on clone, unshare. This function returns flags only for new namespaces.func (n *Namespaces) CloneFlags() uintptr {	var flag int	for _, v := range *n {		if v.Path != "" {			continue		}		flag |= namespaceInfo[v.Type]	}	return uintptr(flag)}func (c *linuxContainer) newInitProcess(p *Process, cmd *exec.Cmd, parentPipe, childPipe *os.File) (*initProcess, error) {     t := "_LIBCONTAINER_INITTYPE=standard"    //    //没错，就是这里～    //    cloneFlags := c.config.Namespaces.CloneFlags()    if cloneFlags&syscall.CLONE_NEWUSER != 0 {        if err := c.addUidGidMappings(cmd.SysProcAttr); err != nil {            // user mappings are not supported            return nil, err        }        enableSetgroups(cmd.SysProcAttr)        // Default to root user when user namespaces are enabled.        if cmd.SysProcAttr.Credential == nil {            cmd.SysProcAttr.Credential = &syscall.Credential{}        }    }    cmd.Env = append(cmd.Env, t)    cmd.SysProcAttr.Cloneflags = cloneFlags    return &initProcess{        cmd:        cmd,        childPipe:  childPipe,        parentPipe: parentPipe,        manager:    c.cgroupManager,        config:     c.newInitConfig(p),    }, nil}

现在，容器运行时，通过OCI这个容器运行时规范同底层的Linux操作系统进行交互，即：把容器操作请求翻译成对Linux操作系统的调用（操作Linux Namespace和Cgroups等）。

参考

转载地址：http://chtpi.baihongyu.com/

你可能感兴趣的文章