Docker原理浅析(2)

╰+哭是因爲堅強的太久メ 2023-06-11 06:24 3阅读 0赞

## namespace ##

### 前言 ###

首先我们先运行一个docker项目，来感受一个pid namespace的例子

docker run -it busybox /bin/sh
    / # ps
    PID   USER     TIME  COMMAND
        1 root      0:00 /bin/sh
        7 root      0:00 ps

根据上面的命令，可以看出容器内部的进程是从1号开始的  
而这种技术就是上节所说的namespace，它其实是linux创建新进程的一个可选参数，而在linux系统中创建现成的系统调用是clone(),比如：

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

这个系统调用会为我们创建一个新的进程，并且返回它的进程号pid

而当我们用clone系统调用创建一个新进程时，就可以在参数中指定CLONE\_NEWPID参数，比如：

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

这样我们就做到了，在这个进程空间里，它的pid是1

### 概述 ###

Namespace是对全局系统资源的一种封装隔离，使得处于不同namespace的进程拥有独立的全局系统资源，改变一个namespace中的系统资源只会影响当前namespace里的进程，对其他namespace中的进程没有影响。目前，Linux内核里面实现了7种不同类型的namespace：

名称        宏定义             隔离内容
    Cgroup      CLONE_NEWCGROUP   Cgroup root directory (since Linux 4.6)
    IPC         CLONE_NEWIPC      System V IPC, POSIX message queues (since Linux 2.6.19)
    Network     CLONE_NEWNET      Network devices, stacks, ports, etc. (since Linux 2.6.24)
    Mount       CLONE_NEWNS       Mount points (since Linux 2.4.19)
    PID         CLONE_NEWPID      Process IDs (since Linux 2.6.24)
    User        CLONE_NEWUSER     User and group IDs (started in Linux 2.6.23 and completed in Linux 3.8)
    UTS         CLONE_NEWUTS      Hostname and NIS domain name (since Linux 2.6.19)

而我们如果想要查看进程所属的namespaces，每个进程都有/proc/\[pid\]/ns/这样一个目录，里面包含了这个进程所属namespace的信息，里面每个文件的描述符都可以用来作为setns函数(后面会介绍)的参数。

#查看当前bash进程所属的namespace
    / # ls -l /proc/$$/ns
    total 0
    lrwxrwxrwx    1 root     root             0 Oct 29 01:49 cgroup -> cgroup:[4026531835]
    lrwxrwxrwx    1 root     root             0 Oct 29 01:49 ipc -> ipc:[4026532331]
    lrwxrwxrwx    1 root     root             0 Oct 29 01:49 mnt -> mnt:[4026532329]
    lrwxrwxrwx    1 root     root             0 Oct 29 01:49 net -> net:[4026532334]
    lrwxrwxrwx    1 root     root             0 Oct 29 01:49 pid -> pid:[4026532332]
    lrwxrwxrwx    1 root     root             0 Oct 29 01:49 user -> user:[4026531837]
    lrwxrwxrwx    1 root     root             0 Oct 29 01:49 uts -> uts:[4026532330]

注：以ipc:\[4026532331\]为例，ipc是namespace的类型，4026532331是inode number，如果两个进程的ipc namespace的inode number一样，说明他们属于同一个namespace。这条规则对其他类型的namespace也同样适用。

#### 跟namcespace相关的API ####

###### Clone(创建一个新的进程并把他放到新的namespace中) ######

int clone(int (*child_func)(void *), void *child_stack
                , int flags, void *arg);
    
    flags： 
        指定一个或者多个上面的CLONE_NEW*（当然也可以包含跟namespace无关的flags）， 
        这样就会创建一个或多个新的不同类型的namespace， 
        并把新创建的子进程加入新创建的这些namespace中。

###### setns(将当前进程加入到已有的namespace中) ######

int setns(int fd, int nstype);
    
    fd： 
        指向/proc/[pid]/ns/目录里相应namespace对应的文件，
        表示要加入哪个namespace
    
    nstype：
        指定namespace的类型（上面的任意一个CLONE_NEW*）：
        1. 如果当前进程不能根据fd得到它的类型，如fd由其他进程创建，
        并通过UNIX domain socket传给当前进程，
        那么就需要通过nstype来指定fd指向的namespace的类型
        2. 如果进程能根据fd得到namespace类型，比如这个fd是由当前进程打开的，
        那么nstype设置为0即可

###### unshare(使当前进程退出指定类型的namespace，并加入到新创建的namespace（相当于创建并加入新的namespace）) ######

int unshare(int flags);
    
    flags：
        指定一个或者多个上面的CLONE_NEW*，
        这样当前进程就退出了当前指定类型的namespace并加入到新创建的namespace

***clone和unshare的区别:***

clone和unshare的功能都是创建并加入新的namespace， 他们的区别是：

*  unshare是使当前进程加入新的namespace
 *  clone是创建一个新的子进程，然后让子进程加入新的namespace，而当前进程保持不变

### UTS namespace(CLONE\_NEWUTS) ###

UTS(UNIX Time Sharing) namespace用来隔离系统的hostname以及NIS domain name。(Network Information System)

#### 创建新的UTS namespace ####

#define _GNU_SOURCE
    #include <sched.h>
    #include <sys/wait.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <string.h>
    
    #define NOT_OK_EXIT(code, msg); {if(code == -1){perror(msg); exit(-1);} }
    
    //子进程从这里开始执行
    static int child_func(void *hostname)
    {
        //设置主机名
        sethostname(hostname, strlen(hostname));
    
        //用一个新的bash来替换掉当前子进程，
        //执行完execlp后，子进程没有退出，也没有创建新的进程,
        //只是当前子进程不再运行自己的代码，而是去执行bash的代码,
        //详情请参考"man execlp"
        //bash退出后，子进程执行完毕
        execlp("bash", "bash", (char *) NULL);
    
        //从这里开始的代码将不会被执行到，因为当前子进程已经被上面的bash替换掉了
    
        return 0;
    }
    
    static char child_stack[1024*1024]; //设置子进程的栈空间为1M
    
    int main(int argc, char *argv[])
    {
        pid_t child_pid;
    
        if (argc < 2) {
            printf("Usage: %s <child-hostname>\n", argv[0]);
            return -1;
        }
    
        //创建并启动子进程，调用该函数后，父进程将继续往后执行，也就是执行后面的waitpid
        child_pid = clone(child_func,  //子进程将执行child_func这个函数
                        //栈是从高位向低位增长，所以这里要指向高位地址
                        child_stack + sizeof(child_stack),
                        //CLONE_NEWUTS表示创建新的UTS namespace，
                        //这里SIGCHLD是子进程退出后返回给父进程的信号，跟namespace无关
                        CLONE_NEWUTS | SIGCHLD,
                        argv[1]);  //传给child_func的参数
        NOT_OK_EXIT(child_pid, "clone");
    
        waitpid(child_pid, NULL, 0); //等待子进程结束
    
        return 0;    //这行执行完之后，父进程结束
    }

在上面的代码中：

*  父进程创建新的子进程，并且设置CLONE\_NEWUTS，这样就会创建新的UTS namespace并且让子进程属于这个新的namespace，然后父进程一直等待子进程退出
 *  子进程在设置好新的hostname后被bash替换掉
 *  当bash退出后，子进程退出，接着父进程也退出

下面运行上面的代码：

#------------------------第一个shell窗口------------------------
    #将上面的代码保存为namespace_uts_demo.c， 
    #然后用gcc将它编译成可执行文件namespace_uts_demo
    [root@hb02-other-172e28e8e23 ~]# gcc namespace_uts_demo.c -o namespace_uts_demo   
    
    #启动程序，传入参数container001
    #创建新的UTS namespace需要root权限，所以用到sudo
    [root@hb02-other-172e28e8e23 ~]# ./namespace_uts_demo container001
    
    #新的bash被启动，从shell的提示符可以看出，hostname已经被改成了container001
    #这里bash的提示符是‘#’，表示bash有root权限，
    #这是因为我们是用sudo来运行的程序，于是我们程序创建的子进程有root权限
    [root@container001 ~]#
    
    #用hostname命令再确认一下
    [root@container001 ~]# hostname
    container001
    
    #pstree是用来查看系统中进程之间父子关系的工具
    #下面的输出过滤掉了跟namespace_uts_demo无关的内容
    #本次操作是通过ssh客户端远程连接到Linux主机进行的，
    #所以bash(110600)的父进程是一系列的sshd进程，
    #我们在bash(110600)里面执行了 ./namespace_uts_demo container001
    #所以有了我们程序namespace_uts_d(110918)对应的进程，
    #我们的程序自己clone了一个新的子进程，由于clone的时候指定了参数CLONE_NEWUTS，
    #所以新的子进程属于一个新的UTS namespace，然后这个新进程调用execlp后被bash替换掉了，
    #于是有了bash(110919)， 这个bash进程拥有所有当前子进程的属性， 
    #由于我们的pstree命令是在bash(110919)里面运行的，
    #所以这里pstree(111551)是bash(110919)的子进程
    [root@container001 ~]# pstree -pl
    systemd(1)─sshd(9429)───sshd(110559)───sshd(110564)───bash(110565)───sudo(110596)───su(110599)───bash(110600)───namespace_urs_d(110918)───bash(110919)───pstree(111551)
    
    #验证一下我们运行的bash进程是不是bash(27334)
    #下面这个命令可以输出当前bash的PID
    [root@container001 ~]# echo $$
    110919
    
    #验证一下我们的父进程和子进程是否不在同一个UTS namespace
    [root@container001 ~]# readlink /proc/110918/ns/uts
    uts:[4026531838]
    [root@container001 ~]# readlink /proc/110919/ns/uts
    uts:[4026532539]
    #果然不属于同一个UTS namespace，说明新的uts namespace创建成功
    
    #默认情况下，子进程应该继承父进程的namespace
    #systemd(1)是我们程序父进程namespace_uts_d(110918)的祖先进程，
    #他们应该属于同一个namespace
    [root@container001 ~]# readlink /proc/1/ns/uts
    uts:[4026531838]
    
    #所有bash(110919)里面执行的进程应该和bash(110919)属于同样的namespace
    #self指向当前运行的进程，在这里即readlink进程
    [root@container001 ~]# readlink /proc/self/ns/uts
    uts:[4026532539]
    
    #------------------------第二个shell窗口------------------------
    #重新打开一个新的shell窗口，确认这个shell和上面的namespace_uts_d(27333)属于同一个namespace
    [root@hb02-other-172e28e8e23 ~]# readlink /proc/$$/ns/uts
    uts:[4026531838]
    
    #老的namespace中的hostname还是原来的，不受新的namespace影响
    [root@hb02-other-172e28e8e23 ~]# hostname
    hb02-other-172e28e8e23
    #有兴趣的同学可以在两个shell窗口里面分别用命令hostname设置hostname试试，
    #会发现他们两个之间相互不受影响，这里就不演示了
    
    
    #------------------------第一个shell窗口------------------------
    #继续回到原来的shell，试试在container001里面再运行一下那个程序会怎样
    [root@container001 ~]# ./namespace_uts_demo container002
    
    #创建了一个新的UTS namespace，hostname被改成了container002
    [root@container002 ~]#
    [root@container002 ~]# hostname
    container002
    
    #新的UTS namespace
    [root@container002 ~]#readlink /proc/$$/ns/uts
    uts:[4026532894]
    
    #进程间的关系和上面的差不多，在后面又生成了namespace_uts_d(27354)和bash(27355)
    [root@container002 ~]# pstree -pl
    systemd(1)─sshd(9429)─┬─sshd(110559)───sshd(110564)───bash(110565)───sudo(110596)───su(110599)───bash(110600)───namespace_urs_d(110918)───bash(110919)───namespace_urs_d(112973)───bash(112974)───pstree(113260)
    
    #退出bash(112974)后，它的父进程namespace_uts_d(112973)也接着退出，
    #于是又回到了进程bash(110919)中，hostname于是也回到了container001
    #注意： 在bash(112974)退出的过程中，并没有任何进程的namespace发生变化，
    #只是所有属于namespace container002的进程都执行完退出了
    [root@container002 ~]# exit
    exit
    [root@container001 ~]#
    [root@container001 ~]# hostname
    container001

### 将当前进程加入指定的namespace ###

#define _GNU_SOURCE
    #include <fcntl.h>
    #include <sched.h>
    #include <stdlib.h>
    #include <stdio.h>
    #include <unistd.h>
    
    #define NOT_OK_EXIT(code, msg); {if(code == -1){perror(msg); exit(-1);} }
    
    int main(int argc, char *argv[])
    {
        int fd, ret;
    
        if (argc < 2) {
            printf("%s /proc/PID/ns/FILE\n", argv[0]);
            return -1;
        }
    
        //获取namespace对应文件的描述符
        fd = open(argv[1], O_RDONLY);
        NOT_OK_EXIT(fd, "open");
    
        //执行完setns后，当前进程将加入指定的namespace
        //这里第二个参数为0，表示由系统自己检测fd对应的是哪种类型的namespace
        ret = setns(fd, 0);
        NOT_OK_EXIT(ret, "open");
    
        //用一个新的bash来替换掉当前子进程
        execlp("bash", "bash", (char *) NULL);
    
        return 0;
    }

再来看结果

#--------------------------第一个shell窗口----------------------
    #重用上面创建的namespace container001
    #先确认一下hostname是否正确，
    [root@container001 ~]# hostname
    container001
    
    #获取bash的PID
    [root@container001 ~]# echo $$
    114526
    
    #得到bash所属的UTS namespace
    [root@container001 ~]# readlink /proc/114526/ns/uts
    uts:[4026532539]
    
    
    
    #--------------------------第二个shell窗口----------------------
    #重新打开一个shell窗口，将上面的代码保存为文件namespace_join.c并编译
    [root@container001 ~]# gcc namespace_join.c -o namespace_join
    
    #运行程序前，确认下当前bash不属于namespace container001
    [root@hb02-other-172e28e8e23 ~]# hostname
    hb02-other-172e28e8e23
    [root@hb02-other-172e28e8e23 ~]# readlink /proc/$$/ns/uts
    uts:[4026531838]
    
    #执行程序，使其加入第一个shell窗口中的bash所在的namespace
    #27334是第一个shell窗口中bash的pid
    [root@hb02-other-172e28e8e23 ~]# ./namespace_join  /proc/114526/ns/uts
    [root@container001 ~]#
    
    #加入成功，bash提示符里面的hostname以及UTS namespace的inode number和第一个shell窗口的都一样
    [root@container001 ~]# hostname
    container001
    [root@container001 ~]# readlink /proc/$$/ns/uts
    uts:[4026532539]

#### 退出当前namespace并加入新创建的namespace ####

#define _GNU_SOURCE
    #include <sched.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <stdio.h>
    
    #define NOT_OK_EXIT(code, msg); {if(code == -1){perror(msg); exit(-1);} }
    
    static void usage(const char *pname)
    {
        char usage[] = "Usage: %s [optins]\n"
                       "Options are:\n"
                       "    -i   unshare IPC namespace\n"
                       "    -m   unshare mount namespace\n"
                       "    -n   unshare network namespace\n"
                       "    -p   unshare PID namespace\n"
                       "    -u   unshare UTS namespace\n"
                       "    -U   unshare user namespace\n";
        printf(usage, pname);
        exit(0);
    }
    
    int main(int argc, char *argv[])
    {
        int flags = 0, opt, ret;
    
        //解析命令行参数，用来决定退出哪个类型的namespace
        while ((opt = getopt(argc, argv, "imnpuUh")) != -1) {
            switch (opt) {
                case 'i': flags |= CLONE_NEWIPC;        break;
                case 'm': flags |= CLONE_NEWNS;         break;
                case 'n': flags |= CLONE_NEWNET;        break;
                case 'p': flags |= CLONE_NEWPID;        break;
                case 'u': flags |= CLONE_NEWUTS;        break;
                case 'U': flags |= CLONE_NEWUSER;       break;
                case 'h': usage(argv[0]);               break;
                default:  usage(argv[0]);
            }
        }
    
        if (flags == 0) {
            usage(argv[0]);
        }
    
        //执行完unshare函数后，当前进程就会退出当前的一个或多个类型的namespace,
        //然后进入到一个或多个新创建的不同类型的namespace
        ret = unshare(flags);
        NOT_OK_EXIT(ret, "unshare");
    
        //用一个新的bash来替换掉当前子进程
        execlp("bash", "bash", (char *) NULL);
    
        return 0;
    }

看运行结果：

#将上面的代码保存为文件namespace_leave.c并编译
    [root@hb02-other-172e28e8e23 ~]# gcc namespace_leave.c -o namespace_leave
    
    #查看当前bash所属的UTS namespace
    [root@hb02-other-172e28e8e23 ~]# readlink /proc/$$/ns/uts
    uts:[4026531838]
    
    #执行程序， -u表示退出并加入新的UTS namespace
    [root@hb02-other-172e28e8e23 ~]#  ./namespace_leave -u
    [root@hb02-other-172e28e8e23 ~]#
    
    #再次查看UTS namespace，已经变了，说明已经离开原来的namespace并加入了新的namespace
    #细心的同学可能已经发现这里的inode number刚好和上面namespace container002的相同，
    #这说明在container002被销毁后，inode number被回收再利用了
    [root@hb02-other-172e28e8e23 ~]# readlink /proc/$$/ns/uts
    uts:[4026532894]

### IPC（Interprocess Communication 进程间通信） namespace (CLONE\_NEWIPC) ###

IPC namespace用来隔离System V IPC objects和POSIX message queues。其中System V IPC objects包含Message queues、Semaphore sets和Shared memory segments.

对于其他几种IPC，下面是我的理解，有可能不对，仅供参考，欢迎指正：

*  signal没必要隔离，因为它和pid密切相关，当pid隔离后，signal自然就隔离了，能不能跨pid namespace发送signal则由pid namespace决定
 *  pipe好像也没必要隔离，对匿名pipe来说，只能在父子进程之间通讯，所以隔离的意义不大，而命名管道和文件系统有关，所以只要做好文件系统的隔离，命名管道也就隔离了
 *  socket和协议栈有关，而不同的network namespace有不同的协议栈，所以socket就被network namespace隔离了

从这篇文章开始，不再像介绍UTS namespace那样自己写代码，而是用ubuntu 16.04中现成的两个工具，他们的实现和上一篇文章中介绍UTS namespace时的代码类似，只是多了一些参数处理

*  nsenter：加入指定进程的指定类型的namespace，然后执行参数中指定的命令。详情请参考帮助文档和代码。
 *  unshare：离开当前指定类型的namespace，创建且加入新的namespace，然后执行参数中指定的命令。详情请参考帮助文档和代码。

#### 示例 ####

这里将以消息队列为例，演示一下隔离效果，在本例中将用到两个ipc相关的命令

*  ipcmk - 创建shared memory segments, message queues, 和semaphore arrays
 *  ipcs - 查看shared memory segments, message queues, 和semaphore arrays的相关信息

为了使演示更直观，我们在创建新的ipc namespace的时候，同时也创建新的uts namespace，然后为新的utsnamespace设置新hostname，这样就能通过shell提示符一眼看出这是属于新的namespace的bash，后面的文章中也采取这种方式启动新的bash。

#--------------------------第一个shell窗口----------------------
    #记下默认的uts和ipc namespace number
    dev@ubuntu:~$ readlink /proc/$$/ns/uts /proc/$$/ns/ipc
    uts:[4026531838]
    ipc:[4026531839]
    
    #确认hostname
    dev@ubuntu:~$ hostname
    ubuntu
    
    #查看现有的ipc Message Queues，默认情况下没有message queue
    dev@ubuntu:~$ ipcs -q
    ------ Message Queues --------
    key        msqid      owner      perms      used-bytes   messages
    
    #创建一个message queue
    dev@ubuntu:~$ ipcmk -Q
    Message queue id: 0
    dev@ubuntu:~$ ipcs -q
    ------ Message Queues --------
    key        msqid      owner      perms      used-bytes   messages
    0x12aa0de5 0          dev        644        0            0
    
    
    #--------------------------第二个shell窗口----------------------
    #重新打开一个shell窗口，确认和上面的shell是在同一个namespace，
    #能看到上面创建的message queue
    dev@ubuntu:~$ readlink /proc/$$/ns/uts /proc/$$/ns/ipc
    uts:[4026531838]
    ipc:[4026531839]
    dev@ubuntu:~$ ipcs -q
    ------ Message Queues --------
    key        msqid      owner      perms      used-bytes   messages
    0x12aa0de5 0          dev        644        0            0
    
    #运行unshare创建新的ipc和uts namespace，并且在新的namespace中启动bash
    #这里-i表示启动新的ipc namespace，-u表示启动新的utsnamespace
    dev@ubuntu:~$ sudo unshare -iu /bin/bash
    root@ubuntu:~#
    
    #确认新的bash已经属于新的ipc和uts namespace了
    root@ubuntu:~# readlink /proc/$$/ns/uts /proc/$$/ns/ipc
    uts:[4026532455]
    ipc:[4026532456]
    
    #设置新的hostname以便和第一个shell里面的bash做区分
    root@ubuntu:~# hostname container001
    root@ubuntu:~# hostname
    container001
    
    #当hostname改变后，bash不会自动修改它的命令行提示符
    #所以运行exec bash重新加载bash
    root@ubuntu:~# exec bash
    root@container001:~#
    root@container001:~# hostname
    container001
    
    #现在各个bash进程间的关系如下
    #bash(24429)是shell窗口打开时的bash
    #bash(27668)是运行sudo unshare创建的bash，和bash(24429)不在同一个namespace
    root@container001:~# pstree -pl
    ├──sshd(24351)───sshd(24428)───bash(24429)───sudo(27667)───bash(27668)───pstree(27695)
    
    #查看message queues，看不到原来namespace里面的消息，说明已经被隔离了
    root@container001:~# ipcs -q
    ------ Message Queues --------
    key        msqid      owner      perms      used-bytes   messages
    
    #创建一条新的message queue
    root@container001:~# ipcmk -Q
    Message queue id: 0
    root@container001:~# ipcs -q
    ------ Message Queues --------
    key        msqid      owner      perms      used-bytes   messages
    0x54b08fc2 0          root       644        0            0
    
    #--------------------------第一个shell窗口----------------------
    #回到第一个shell窗口，看看有没有受到新namespace的影响
    dev@ubuntu:~$ ipcs -q
    ------ Message Queues --------
    key        msqid      owner      perms      used-bytes   messages
    0x12aa0de5 0          dev        644        0            0
    #完全无影响，还是原来的信息
    
    #试着加入第二个shell窗口里面bash的uts和ipc namespace
    #-t后面跟pid用来指定加入哪个进程所在的namespace
    #这里27668是第二个shell中正在运行的bash的pid
    #加入成功后将运行/bin/bash
    dev@ubuntu:~$ sudo nsenter -t 27668 -u -i /bin/bash
    
    #加入成功，bash的提示符也自动变过来了
    root@container001:~# readlink /proc/$$/ns/uts /proc/$$/ns/ipc
    uts:[4026532455]
    ipc:[4026532456]
    
    #显示的是新namespace里的message queues
    root@container001:~# ipcs -q
    ------ Message Queues --------
    key        msqid      owner      perms      used-bytes   messages
    0x54b08fc2 0          root       644        0            0

上面介绍了IPC namespace和两个常用的跟namespace相关的工具，从演示过程可以看出，IPC namespace差不多和UTS namespace一样简单，没有太复杂的逻辑，也没有父子namespace关系。不过后续将要介绍的其他namespace就要比这个复杂多了。

### mount namespaces (CLONE\_NEWNS) ###

Mount namespace用来隔离文件系统的挂载点, 使得不同的mount namespace拥有自己独立的挂载点信息，不同的namespace之间不会相互影响，这对于构建用户或者容器自己的文件系统目录非常有用。

当前进程所在mount namespace里的所有挂载信息可以在/proc/\[pid\]/mounts、/proc/\[pid\]/mountinfo和/proc/\[pid\]/mountstats里面找到。

Mount namespaces是第一个被加入Linux的namespace，由于当时没想到还会引入其它的namespace，所以取名为CLONE\_NEWNS，而没有叫CLONE\_NEWMOUNT。

每个mount namespace都拥有一份自己的挂载点列表，当用clone或者unshare函数创建新的mount namespace时，新创建的namespace将拷贝一份老namespace里的挂载点列表，但从这之后，他们就没有关系了，通过mount和umount增加和删除各自namespace里面的挂载点都不会相互影响。

#### 演示 ####

#--------------------------第一个shell窗口----------------------
    #先准备两个iso文件，用于后面的mount测试
    [root@hb02-other-172e28e8e23 ~]# mkdir iso
    [root@hb02-other-172e28e8e23 ~]# cd iso/
    [root@hb02-other-172e28e8e23 iso]# mkdir -p iso01/subdir01
    [root@hb02-other-172e28e8e23 iso]# mkdir -p iso02/subdir02
    [root@hb02-other-172e28e8e23 iso]# mkisofs -o ./001.iso ./iso01
    [root@hb02-other-172e28e8e23 iso]# mkisofs -o ./002.iso ./iso02
    [root@hb02-other-172e28e8e23 iso]# ls
    001.iso  002.iso  iso01  iso02
    #准备目录用于mount
    [root@hb02-other-172e28e8e23 iso]# mkdir /mnt/iso1 /mnt/iso2 
    #查看当前所在的mount namespace
    [root@hb02-other-172e28e8e23 iso]# readlink /proc/$$/ns/mnt
    mnt:[4026531840]
    
    #mount 001.iso 到 /mnt/iso1/
    [root@hb02-other-172e28e8e23 iso]# mount ./001.iso /mnt/iso1/
    mount: /dev/loop2 is write-protected, mounting read-only
    
    #mount成功
    [root@hb02-other-172e28e8e23 iso]# mount |grep /001.iso
    /root/iso/001.iso on /mnt/iso1 type iso9660 (ro,relatime,nojoliet,check=s,map=n,blocksize=2048)
    
    #创建并进入新的mount和uts namespace
    [root@hb02-other-172e28e8e23 iso]# unshare --mount --uts /bin/bash
    #更改hostname并重新加载bash
    [root@hb02-other-172e28e8e23 iso]# hostname container001
    [root@hb02-other-172e28e8e23 iso]# exec bash
    [root@container001 iso]#
    
    #查看新的mount namespace
    [root@container001 iso]# readlink /proc/$$/ns/mnt
    mnt:[4026532539]
    
    #老namespace里的挂载点的信息已经拷贝到新的namespace里面来了
    [root@container001 iso]# mount |grep /001.iso
    /root/iso/001.iso on /mnt/iso1 type iso9660 (ro,relatime,nojoliet,check=s,map=n,blocksize=2048)
    
    #在新namespace中mount 002.iso
    [root@container001 iso]# mount ./002.iso /mnt/iso2/
    mount: /dev/loop3 is write-protected, mounting read-only
    [root@container001 iso]# mount |grep iso
    /root/iso/001.iso on /mnt/iso1 type iso9660 (ro,relatime,nojoliet,check=s,map=n,blocksize=2048)
    /root/iso/002.iso on /mnt/iso2 type iso9660 (ro,relatime,nojoliet,check=s,map=n,blocksize=2048)
    #umount 001.iso
    [root@container001 iso]# umount /mnt/iso1
    [root@container001 iso]# mount |grep iso
    /root/iso/002.iso on /mnt/iso2 type iso9660 (ro,relatime,nojoliet,check=s,map=n,blocksize=2048)
    
    #/mnt/iso1目录变为空
    [root@container001 iso]# ls /mnt/iso1
    [root@container001 iso]#
    
    #--------------------------第二个shell窗口----------------------
    #打开新的shell窗口，老namespace中001.iso的挂载信息还在
    #而在新namespace里面mount的002.iso这里看不到
    [root@hb02-other-172e28e8e23 ~]# mount |grep iso
    /root/iso/001.iso on /mnt/iso1 type iso9660 (ro,relatime,nojoliet,check=s,map=n,blocksize=2048)
    #iso1目录里面也有内容
    [root@hb02-other-172e28e8e23 ~]# ls /mnt/iso1
    subdir01
    #说明两个namespace中的mount信息是隔离的

#### Shared subtrees ####

在某些情况下，比如系统添加了一个新的硬盘，这个时候如果mount namespace是完全隔离的，想要在各个namespace里面用这个硬盘，就需要在每个namespace里面手动mount这个硬盘，这个是很麻烦的，这时Shared subtrees就可以帮助我们解决这个问题。

#--------------------------第一个shell窗口----------------------
    #准备4个虚拟的disk，并在上面创建ext2文件系统，用于后续的mount测试
    dev@ubuntu:~/iso$ cd && mkdir disks && cd disks
    dev@ubuntu:~/disks$ dd if=/dev/zero bs=1M count=32 of=./disk1.img
    dev@ubuntu:~/disks$ dd if=/dev/zero bs=1M count=32 of=./disk2.img
    dev@ubuntu:~/disks$ dd if=/dev/zero bs=1M count=32 of=./disk3.img
    dev@ubuntu:~/disks$ dd if=/dev/zero bs=1M count=32 of=./disk4.img
    dev@ubuntu:~/disks$ mkfs.ext2 ./disk1.img
    dev@ubuntu:~/disks$ mkfs.ext2 ./disk2.img
    dev@ubuntu:~/disks$ mkfs.ext2 ./disk3.img
    dev@ubuntu:~/disks$ mkfs.ext2 ./disk4.img
    #准备两个目录用于挂载上面创建的disk
    dev@ubuntu:~/disks$ mkdir disk1 disk2
    dev@ubuntu:~/disks$ ls
    disk1  disk1.img  disk2  disk2.img  disk3.img  disk4.img
    
    
    #显式的分别以shared和private方式挂载disk1和disk2
    dev@ubuntu:~/disks$ sudo mount --make-shared ./disk1.img ./disk1
    dev@ubuntu:~/disks$ sudo mount --make-private ./disk2.img ./disk2
    dev@ubuntu:~/disks$ cat /proc/self/mountinfo |grep disk| sed 's/ - .*//'
    164 24 7:1 / /home/dev/disks/disk1 rw,relatime shared:105
    173 24 7:2 / /home/dev/disks/disk2 rw,relatime
    
    #查看mount namespace编号
    dev@ubuntu:~/disks$ readlink /proc/$$/ns/mnt
    mnt:[4026531840]
    
    #--------------------------第二个shell窗口----------------------
    #重新打开一个新的shell窗口
    dev@ubuntu:~$ cd ./disks
    #创建新的mount namespace
    #默认情况下，unshare会将新namespace里面的所有挂载点的类型设置成private，
    #所以这里用到了参数--propagation unchanged，
    #让新namespace里的挂载点的类型和老namespace里保持一致。
    #--propagation参数还支持private|shared|slave类型，
    #和mount命令的那些--make-private参数一样，
    #他们的背后都是通过调用mount（...）函数传入不同的参数实现的
    dev@ubuntu:~/disks$ sudo unshare --mount --uts --propagation unchanged /bin/bash
    root@ubuntu:~/disks# hostname container001
    root@ubuntu:~/disks# exec bash
    root@container001:~/disks# 
    
    #确认已经是在新的mount namespace里面了
    root@container001:~/disks# readlink /proc/$$/ns/mnt
    mnt:[4026532463]
    
    #由于前面指定了--propagation unchanged，
    #所以新namespace里面的/home/dev/disks/disk1也是shared，
    #且和老namespace里面的/home/dev/disks/disk1属于同一个peer group 105
    #因为在不同的namespace里面，所以这里挂载点的ID和原来namespace里的不一样了
    root@container001:~/disks# cat /proc/self/mountinfo |grep disk| sed 's/ - .*//'
    221 177 7:1 / /home/dev/disks/disk1 rw,relatime shared:105
    222 177 7:2 / /home/dev/disks/disk2 rw,relatime
    
    #分别在disk1和disk2目录下创建disk3和disk4，然后挂载disk3，disk4到这两个目录
    root@container001:~/disks# mkdir ./disk1/disk3 ./disk2/disk4
    root@container001:~/disks# mount ./disk3.img ./disk1/disk3/
    root@container001:~/disks# mount ./disk4.img ./disk2/disk4/
    root@container001:~/disks# cat /proc/self/mountinfo |grep disk| sed 's/ - .*//'
    221 177 7:1 / /home/dev/disks/disk1 rw,relatime shared:105
    222 177 7:2 / /home/dev/disks/disk2 rw,relatime
    223 221 7:3 / /home/dev/disks/disk1/disk3 rw,relatime shared:107
    227 222 7:4 / /home/dev/disks/disk2/disk4 rw,relatime
    
    #--------------------------第一个shell窗口----------------------
    #回到第一个shell窗口
    
    #可以看出由于/home/dev/disks/disk1是shared，且两个namespace里的这个挂载点都属于peer group 105，
    #所以在新namespace里面挂载的disk3，在老的namespace里面也看的到
    #但是看不到disk4的挂载信息，那是因为/home/dev/disks/disk2是private的
    dev@ubuntu:~/disks$ cat /proc/self/mountinfo |grep disk| sed 's/ - .*//'
    164 24 7:1 / /home/dev/disks/disk1 rw,relatime shared:105
    173 24 7:2 / /home/dev/disks/disk2 rw,relatime
    224 164 7:3 / /home/dev/disks/disk1/disk3 rw,relatime shared:107
    
    #我们可以随时修改挂载点的propagation type
    #这里我们通过mount命令将disk3改成了private类型
    dev@ubuntu:~/disks$ sudo mount --make-private /home/dev/disks/disk1/disk3
    dev@ubuntu:~/disks$ cat /proc/self/mountinfo |grep disk3| sed 's/ - .*//'
    224 164 7:3 / /home/dev/disks/disk1/disk3 rw,relatime
    
    #--------------------------第二个shell窗口----------------------
    #回到第二个shell窗口，disk3的propagation type还是shared，
    #表明在老的namespace里面对propagation type的修改不会影响新namespace里面的挂载点
    root@container001:~/disks# cat /proc/self/mountinfo |grep disk3| sed 's/ - .*//'
    223 221 7:3 / /home/dev/disks/disk1/disk3 rw,relatime shared:107

### pid namespace (CLONE\_NEWPID) ###

PID namespaces用来隔离进程的ID空间，使得不同pid namespace里的进程ID可以重复且相互之间不影响。

PID namespace可以嵌套，也就是说有父子关系，在当前namespace里面创建的所有新的namespace都是当前namespace的子namespace。父namespace里面可以看到所有子孙后代namespace里的进程信息，而子namespace里看不到祖先或者兄弟namespace里的进程信息。

目前PID namespace最多可以嵌套32层，由内核中的宏MAX\_PID\_NS\_LEVEL来定义

Linux下的每个进程都有一个对应的/proc/PID目录，该目录包含了大量的有关当前进程的信息。 对一个PID namespace而言，/proc目录只包含当前namespace和它所有子孙后代namespace里的进程的信息。

在Linux系统中，进程ID从1开始往后不断增加，并且不能重复（当然进程退出后，ID会被回收再利用），进程ID为1的进程是内核启动的第一个应用层进程，一般是init进程（现在采用systemd的系统第一个进程是systemd），具有特殊意义，当系统中一个进程的父进程退出时，内核会指定init进程成为这个进程的新父进程，而当init进程退出时，系统也将退出。

除了在init进程里指定了handler的信号外，内核会帮init进程屏蔽掉其他任何信号，这样可以防止其他进程不小心kill掉init进程导致系统挂掉。不过有了PID namespace后，可以通过在父namespace中发送SIGKILL或者SIGSTOP信号来终止子namespace中的ID为1的进程。

由于ID为1的进程的特殊性，所以每个PID namespace的第一个进程的ID都是1。当这个进程运行停止后，内核将会给这个namespace里的所有其他进程发送SIGKILL信号，致使其他所有进程都停止，于是namespace被销毁掉。

#### 示例 ####

#查看当前pid namespace的ID
    dev@ubuntu:~$ readlink /proc/self/ns/pid
    pid:[4026531836]
    
    #启动新的pid namespace
    #这里同时也启动了新的uts和mount namespace
    #新的uts是为了设置一个新的hostname，便于和老的namespace区分
    #新的mount namespace是为了方便我们修改新namespace里面的mount信息，
    #因为这样不会对老namespace造成影响
    #这里--fork是为了让unshare进程fork一个新的进程出来，然后再用bash替换掉新的进程
    #这是pid namespace本身的限制，进程所属的pid namespace在它创建的时候就确定了，不能更改，
    #所以调用unshare和nsenter后，原来的进程还是属于老的namespace，
    #而新fork出来的进程才属于新的namespace
    dev@ubuntu:~$ sudo unshare --uts --pid --mount --fork /bin/bash
    root@ubuntu:~# hostname container001
    root@ubuntu:~# exec bash
    root@container001:~#
    
    #查看进程间关系，当前bash(31646)确实是unshare的子进程
    root@container001:~# pstree -pl
    ├─sshd(955)─┬─sshd(17810)───sshd(17891)───bash(17892)───sudo(31644)──
    ─unshare(31645)───bash(31646)───pstree(31677)
    #他们属于不同的pid namespace
    root@container001:~# readlink /proc/31645/ns/pid
    pid:[4026531836]
    root@container001:~# readlink /proc/31646/ns/pid
    pid:[4026532469]
    
    #但为什么通过这种方式查看到的namespace还是老的呢？
    root@container001:~# readlink /proc/$$/ns/pid
    pid:[4026531836]
    
    #由于我们实际上已经是在新的namespace里了，并且当前bash是当前namespace的第一个进程
    #所以在新的namespace里看到的他的进程ID是1
    root@container001:~# echo $$
    1
    #但由于我们新的namespace的挂载信息是从老的namespace拷贝过来的，
    #所以这里看到的还是老namespace里面的进程号为1的信息
    root@container001:~# readlink /proc/1/ns/pid
    pid:[4026531836]
    #ps命令依赖/proc目录，所以ps的输出还是老namespace的视图
    root@container001:~# ps ef
    UID        PID  PPID  C STIME TTY          TIME CMD
    root         1     0  0 7月07 ?       00:00:06 /sbin/init
    root         2     0  0 7月07 ?       00:00:00 [kthreadd]
     ...
    root     31644 17892  0 7月14 pts/0   00:00:00 sudo unshare --uts --pid --mount --fork /bin/bash
    root     31645 31644  0 7月14 pts/0   00:00:00 unshare --uts --pid --mount --fork /bin/bash
    
    #所以我们需要重新挂载我们的/proc目录
    root@container001:~# mount -t proc proc /proc
    
    #重新挂载后，能看到我们新的pid namespace ID了
    root@container001:~# readlink /proc/$$/ns/pid
    pid:[4026532469]
    #ps的输出也正常了
    root@container001:~# ps -ef
    UID        PID  PPID  C STIME TTY          TIME CMD
    root         1     0  0 7月14 pts/0   00:00:00 bash
    root        44     1  0 00:06 pts/0    00:00:00 ps -ef

### network namespace (CLONE\_NEWNET) ###

network namespace用来隔离网络设备, IP地址, 端口等. 每个namespace将会有自己独立的网络栈，路由表，防火墙规则，socket等。

每个新的network namespace默认有一个本地环回接口，除了lo接口外，所有的其他网络设备（物理/虚拟网络接口，网桥等）只能属于一个network namespace。每个socket也只能属于一个network namespace。

当新的network namespace被创建时，lo接口默认是关闭的，需要自己手动启动起

标记为"local devices"的设备不能从一个namespace移动到另一个namespace，比如loopback, bridge, ppp等，我们可以通过ethtool -k命令来查看设备的netns-local属性。

#这里“on”表示该设备不能被移动到其他network namespace
    dev@ubuntu:~$ ethtool -k lo|grep netns-local
    netns-local: on [fixed]

#### 示例 ####

#--------------------------第一个shell窗口----------------------
    #记录默认network namespace ID
    dev@ubuntu:~$ readlink /proc/$$/ns/net
    net:[4026531957]
    
    #创建新的network namespace
    dev@ubuntu:~$ sudo unshare --uts --net /bin/bash
    root@ubuntu:~# hostname container001
    root@ubuntu:~# exec bash
    root@container001:~# readlink /proc/$$/ns/net
    net:[4026532478]
    
    #运行ifconfig啥都没有
    root@container001:~# ifconfig
    root@container001:~#
    
    #启动lo （这里不详细介绍ip这个tool的用法，请参考man ip）
    root@container001:~# ip link set lo up
    root@container001:~# ifconfig
    lo        Link encap:Local Loopback
              inet addr:127.0.0.1  Mask:255.0.0.0
              inet6 addr: ::1/128 Scope:Host
              UP LOOPBACK RUNNING  MTU:65536  Metric:1
              RX packets:0 errors:0 dropped:0 overruns:0 frame:0
              TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
              collisions:0 txqueuelen:1
              RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)
    
    root@container001:~# ping 127.0.0.1
    PING 127.0.0.1 (127.0.0.1) 56(84) bytes of data.
    64 bytes from 127.0.0.1: icmp_seq=1 ttl=64 time=0.070 ms
    64 bytes from 127.0.0.1: icmp_seq=2 ttl=64 time=0.015 ms
    
    #获取当前bash进程的PID
    root@container001:~# echo $$
    15812
    
    #--------------------------第二个shell窗口----------------------
    #创建新的虚拟以太网设备，让两个namespace能通讯
    dev@ubuntu:~$ sudo ip link add veth0 type veth peer name veth1
    
    #将veth1移动到上面第一个窗口中的namespace
    #这里15812是上面bash的PID
    dev@ubuntu:~$ sudo ip link set veth1 netns 15812
    
    #为veth0分配IP并启动veth0
    dev@ubuntu:~$ sudo ip address add dev veth0 192.168.8.1/24
    dev@ubuntu:~$ sudo ip link set veth0 up
    dev@ubuntu:~$ ifconfig veth0
    veth0     Link encap:Ethernet  HWaddr 9a:4d:d5:96:b5:36
              inet addr:192.168.8.1  Bcast:0.0.0.0  Mask:255.255.255.0
              inet6 addr: fe80::984d:d5ff:fe96:b536/64 Scope:Link
              UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
              RX packets:8 errors:0 dropped:0 overruns:0 frame:0
              TX packets:8 errors:0 dropped:0 overruns:0 carrier:0
              collisions:0 txqueuelen:1000
              RX bytes:648 (648.0 B)  TX bytes:648 (648.0 B)
    
    #--------------------------第一个shell窗口----------------------
    #为veth1分配IP地址并启动它
    root@container001:~# ip address add dev veth1 192.168.8.2/24
    root@container001:~# ip link set veth1 up
    root@container001:~# ifconfig veth1
    veth1     Link encap:Ethernet  HWaddr 6a:dc:59:79:3c:8b
              inet addr:192.168.8.2  Bcast:0.0.0.0  Mask:255.255.255.0
              inet6 addr: fe80::68dc:59ff:fe79:3c8b/64 Scope:Link
              UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
              RX packets:8 errors:0 dropped:0 overruns:0 frame:0
              TX packets:8 errors:0 dropped:0 overruns:0 carrier:0
              collisions:0 txqueuelen:1000
              RX bytes:648 (648.0 B)  TX bytes:648 (648.0 B)
    
    #连接成功
    root@container001:~# ping 192.168.8.1
    PING 192.168.8.1 (192.168.8.1) 56(84) bytes of data.
    64 bytes from 192.168.8.1: icmp_seq=1 ttl=64 time=0.098 ms
    64 bytes from 192.168.8.1: icmp_seq=2 ttl=64 time=0.023 ms

到目前为止，两个namespace之间可以网络通信了，但在container001里还是不能访问外网。下面将通过NAT的方式让container001能够上外网。这部分内容完全是网络相关的知识，跟namespace已经没什么关系了

#--------------------------第二个shell窗口----------------------
    #回到上面示例中的第二个窗口
    
    #确认IP forward是否已经开通，这里1表示开通了
    #如果你的机器上是0，请运行这个命令将它改为1： sudo sysctl -w net.ipv4.ip_forward=1
    dev@ubuntu:~$ cat /proc/sys/net/ipv4/ip_forward
    1
    
    #添加NAT规则，这里ens32是机器上连接外网的网卡
    #关于iptables和nat都比较复杂，这里不做解释
    dev@ubuntu:~$ sudo iptables -t nat -A POSTROUTING -o ens32 -j MASQUERADE
    
    #--------------------------第一个shell窗口----------------------
    #回到第一个窗口，添加默认网关
    root@container001:~# ip route add default via 192.168.8.1
    root@container001:~# route -n
    Kernel IP routing table
    Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
    0.0.0.0         192.168.8.1     0.0.0.0         UG    0      0        0 veth1
    192.168.8.0     0.0.0.0         255.255.255.0   U     0      0        0 veth1
    
    #这样就可以访问外网了
    #由于测试环境的限制，所以采用下面的方式检测网络是否畅通
    #如果网络没有什么限制的话，随便ping一个外部的IP测试就可以了
    root@container001:~# curl -I www.google.com
    HTTP/1.1 200 OK
    Date: Fri, 15 Jul 2016 08:12:03 GMT

### user namespace (CLONE\_NEWUSER) ###

User namespace用来隔离user权限相关的Linux资源，包括user IDs and group IDs，keys , 和capabilities.

这是目前实现的namespace中最复杂的一个，因为user和权限息息相关，而权限又事关容器的安全，所以稍有不慎，就会出安全问题。

user namespace可以嵌套（目前内核控制最多32层），除了系统默认的user namespace外，所有的user namespace都有一个父user namespace，每个user namespace都可以有零到多个子user namespace。 当在一个进程中调用unshare或者clone创建新的user namespace时，当前进程原来所在的user namespace为父user namespace，新的user namespace为子user namespace.

在不同的user namespace中，同样一个用户的user ID 和group ID可以不一样，换句话说，一个用户可以在父user namespace中是普通用户，在子user namespace中是超级用户（超级用户只相对于子user namespace所拥有的资源，无法访问其他user namespace中需要超级用户才能访问资源）。

#### 创建user namespace ####

#--------------------------第一个shell窗口----------------------
    #先记录下目前的id，gid和user namespace
    dev@ubuntu:~$ id
    uid=1000(dev) gid=1000(dev) groups=1000(dev),4(adm),24(cdrom),27(sudo)
    dev@ubuntu:~$ readlink /proc/$$/ns/user
    user:[4026531837]
    
    #创建新的user namespace
    dev@ubuntu:~$ unshare --user /bin/bash
    nobody@ubuntu:~$ readlink /proc/$$/ns/user
    user:[4026532464]
    nobody@ubuntu:~$ id
    uid=65534(nobody) gid=65534(nogroup) groups=65534(nogroup)

为什么上面例子中显示的用户名是nobody，它的id和gid都是65534？

这是因为我们还没有映射父user namespace的user ID和group ID到子user namespace中来，这一步是必须的，因为这样系统才能控制一个user namespace里的用户在其他user namespace中的权限。（比如给其他user namespace中的进程发送信号，或者访问属于其他user namespace挂载的文件）

如果没有映射的话，当在新的user namespace中用getuid()和getgid()获取user id和group id时，系统将返回文件/proc/sys/kernel/overflowuid中定义的user ID以及proc/sys/kernel/overflowgid中定义的group ID，它们的默认值都是65534。也就是说如果没有指定映射关系的话，会默认映射到ID65534。

下面看看这个user能干些什么

#--------------------------第一个shell窗口----------------------
    #ls的结果显示/root目录属于nobody
    nobody@ubuntu:~$ ls -l /|grep root
    drwx------   3 nobody nogroup  4096 7月   8 18:39 root
    #但是当前的nobody账号访问不了，说明这两个nobody不是一个ID，他们之间没有映射关系
    nobody@ubuntu:~$ ls /root
    ls: cannot open directory '/root': Permission denied
    
    #这里显示/home/dev目录属于nobody
    nobody@ubuntu:~$ ls -l /home/
    drwxr-xr-x 11 nobody nogroup 4096 7月   8 18:40 dev
    #touch成功，说明虽然没有显式的映射ID，但还是能访问父user namespace里dev账号拥有的资源
    #说明他们背后还是有映射关系
    nobody@ubuntu:~$ touch /home/dev/temp01
    nobody@ubuntu:~$

#### 映射user ID和group ID ####

通常情况下，创建新的user namespace后，第一件事就是映射user和group ID. 映射ID的方法是添加配置到/proc/PID/uid\_map和/proc/PID/gid\_map（这里的PID是新user namespace中的进程ID，刚开始时这两个文件都是空的）.

这两个文件里面的配置格式如下（可以有多条）：

ID-inside-ns ID-outside-ns length
    
    举个例子, 0 1000 256这条配置就表示父user namespace中的1000~1256映射到新user namespace中的0~256。

### 利用Namespace创建一个简单可用的容器 ###

#### 准备container的根目录 ####

#创建一个单独的目录，后续所有的操作都在该目录下进行，目录名称无特殊要求
    [root@hb02-other-172e28e8e23 ~]# mkdir chroot && cd chroot
    #下载编译好的busybox可执行文件
    [root@hb02-other-172e28e8e23 chroot]# wget https://busybox.net/downloads/binaries/1.21.1/busybox-x86_64
    #创建new_root/bin目录，new_root将会是新容器的根目录，bin目录用来放busybox
    #由于/bin默认就在PATH中，所以里面放的程序都可以直接在shell里面执行，不需要带完整的路径
    [root@hb02-other-172e28e8e23 chroot]# mkdir -p new_root/bin
    [root@hb02-other-172e28e8e23 chroot]# chmod +x ./busybox-x86_64
    
    #将busybox-x86_64移到bin目录下，并重命名为busybox
    [root@hb02-other-172e28e8e23 chroot]# mv busybox-x86_64 new_root/bin/busybox
    #运行ls试试，确保busybox能正常工作
    [root@hb02-other-172e28e8e23 chroot]# ./new_root/bin/busybox ls
    new_root
    
    #安装busybox到bin目录，不安装的话每次执行ls命令都需要使用上面那种格式： busybox ls
    #安装之后就会创建一个ls到busybox的硬链接，这样执行ls的时候就不用再输入前面的busybox了
    [root@hb02-other-172e28e8e23 chroot]# ./new_root/bin/busybox --install ./new_root/bin/
    
    #运行下bin下面的ls，确保安装成功
    [root@hb02-other-172e28e8e23 chroot]# ls -l ./new_root/bin/ls
    -rwxr-xr-x. 348 root root 973200 Jul  9  2013 ./new_root/bin/ls
    [root@hb02-other-172e28e8e23 chroot]# ./new_root/bin/ls
    new_root
    
    #使用chroot命令，切换根目录
    [root@hb02-other-172e28e8e23 chroot]# chroot ./new_root/ sh
    
    #切换成功，由于new_root下面只有busybox，没有任何配置文件，
    #所以shell的提示符里只包含当前目录
    #尝试运行几个命令，一切正常
    / # ls
    bin
    / # which ls
    /bin/ls
    / # hostname
    hb02-other-172e28e8e23
    / # id
    uid=0 gid=0 groups=0
    / # exit
    dev@ubuntu:~/chroot$

#### 创建容器并做相关配置 ####

#新建/data目录用来在主机和容器之间共享数据
    [root@hb02-other-172e28e8e23 chroot]# mkdir /data
    [root@hb02-other-172e28e8e23 chroot]# chown dev:dev /data
    [root@hb02-other-172e28e8e23 chroot]#  touch /data/001
    
    #创建新的容器，指定所有namespace相关的参数，
    #这里--propagation private是为了让容器里的mount point都变成private的，
    #这是因为pivot_root命令需要原来根目录的挂载点为private，
    #只有我们需要在host和container之间共享挂载信息的时候，才需要使用shared或者slave类型
    [root@hb02-other-172e28e8e23 chroot]# unshare --user --mount --ipc --pid --net --uts -r --fork --propagation private bash
    #设置容器的主机名
    [root@hb02-other-172e28e8e23 chroot]# hostname container01
    [root@hb02-other-172e28e8e23 chroot]# exec bash
    
    #创建old_root用于pivot_root命令，创建data目录用于绑定/data目录
    [root@container01 chroot]# mkdir -p ./new_root/old_root/ ./new_root/data/
    
    #由于pivot_root命令要求老的根目录和新的根目录不能在同一个挂载点下，
    #所以这里利用bind mount，在原地创建一个新的挂载点
    [root@container01 chroot]# mount --bind ./new_root/ ./new_root/
    
    #将/data目录绑定到new_root/data，这样pivot_root后，就能访问/data下的东西了
    [root@container01 chroot]# mount --bind /data ./new_root/data
    
    #进入new_root目录，然后切换根目录
    [root@container01 chroot]# cd new_root/
    [root@container01 new_root]# pivot_root ./ ./old_root/
    
    #但shell提示符里显示的当前目录还是原来的目录，没有切换到‘/’下，
    #这是因为当前运行的shell还是host里面的bash
    [root@container01 new_root]# ls
    bin       data      old_root
    
    #重新加载new_root下面的shell，这样contianer和host就没有关系了，
    #从shell提示符中可以看出，当前目录已经变成了‘/’
    [root@container01 new_root]# exec sh
    / #
    #由于没有/etc目录，也就没有相关的profile，于是shell的提示符里面只包含当前路径。
    
    #设置PS1环境变量，让shell提示符好看点，这里直接写了root在提示符里面，
    #是因为我们新的container里面没有账号相关的配置文件，
    #虽然系统知道当前账号的ID是0，但不知道账号的用户名是什么。
    / # export PS1='root@$(hostname):$(pwd)# '
    root@container01:/# 
    
    #没有/etc目录，没有user相关的配置文件，所以不知道ID为0的用户名是什么
    root@container01:/# whoami
    whoami: unknown uid 0
    
    #mount命令依赖于/proc目录，所以这里mount操作失败
    root@container01:/# mount
    mount: no /proc/mounts
    
    #重新mount /proc
    root@container01:/# mkdir /proc
    root@container01:/# mount -t proc none /proc
    
    #这时可以看到所有的mount信息了，从host复制过来的mount信息都挂载在/old_root目录下
    root@container01:/# mount
    /dev/mapper/ubuntu--vg-root on /old_root type ext4 (rw,relatime,errors=remount-ro,data=ordered)
    udev on /old_root/dev type devtmpfs (rw,nosuid,relatime,size=1005080k,nr_inodes=251270,mode=755)
    devpts on /old_root/dev/pts type devpts (rw,nosuid,noexec,relatime,mode=600,ptmxmode=000)
    tmpfs on /old_root/dev/shm type tmpfs (rw,nosuid,nodev)
    ......
    /dev/mapper/ubuntu--vg-root on / type ext4 (rw,relatime,errors=remount-ro,data=ordered)
    /dev/mapper/ubuntu--vg-root on /data type ext4 (rw,relatime,errors=remount-ro,data=ordered)
    none on /proc type proc (rw,nodev,relatime)
    
    #umount掉/old_root下的所有mount point
    root@container01:/# umount -l /old_root
    #这时候就只剩下根目录，/proc，/data三个挂载点了
    root@container01:/# mount
    /dev/mapper/ubuntu--vg-root on / type ext4 (rw,relatime,errors=remount-ro,data=ordered)
    /dev/mapper/ubuntu--vg-root on /data type ext4 (rw,relatime,errors=remount-ro,data=ordered)
    none on /proc type proc (rw,nodev,relatime)
    
    #试试cd命令，提示失败， $HOME还是指向老的/home/dev，
    #除了$HOME之外，还有其他一些环境变量也有同样的问题。
    #这主要是由于我们新的container中缺少配置文件，导致很多环境变量没有更新。
    root@container01:/# cd
    sh: cd: can not cd to /home/dev
    
    #试试ps，显示的是container里面启动的进程
    root@container01:/# ps
    PID   USER     TIME   COMMAND
        1 0          0:00 sh
       55 0          0:00 ps
    
    #touch文件001成功
    root@container01:/# touch /data/001
    #新创建一个002文件
    root@container01:/# touch /data/002
    root@container01:/# ls /data
    001  002
    
    #退出contianer01，在/data目录能看到我们上面在container01种创建的002文件
    root@container01:/# exit
    dev@ubuntu:~/chroot$ ls /data
    001  002

参考资料：  
https://segmentfault.com/blog/wuyangchun