DOCKER基础技术：LINUX NAMESPACE（上）

时间  2019-11-11
标签 docker 基础 技术 linux namespace 栏目 Docker 繁體版
原文   原文链接

时下最热的技术莫过于Docker了，不少人都以为Docker是个新技术，其实否则，Docker除了其编程语言用go比较新外，其实它还真不是个新东西，也就是个新瓶装旧酒的东西，所谓的The New “Old Stuff”。Docker和Docker衍生的东西用到了不少很酷的技术，我会用几篇 文章来把这些技术给你们作个介绍，但愿经过这些文章你们能够本身打造一个山寨版的docker。php

固然，文章的风格必定会尊重时下的“流行”——咱们再也没有整块整块的时间去看书去专研，而咱们只有看微博微信那样的碎片时间（那怕咱们有整块的时间，也被那些在手机上的APP碎片化了）。因此，这些文章的风格必然坚持“马桶风格”（但愿简单到占用你拉一泡屎就时间，并且你还不用动脑子，并能学到些东西）html

废话少说，咱们开始。先从Linux Namespace开始。node

 简介

Linux Namespace是Linux提供的一种内核级别环境隔离的方法。不知道你是否还记得很早之前的Unix有一个叫chroot的系统调用（经过修改根目录把用户jail到一个特定目录下），chroot提供了一种简单的隔离模式：chroot内部的文件系统没法访问外部的内容。Linux Namespace在此基础上，提供了对UTS、IPC、mount、PID、network、User等的隔离机制。python

 

举个例子，咱们都知道，Linux下的超级父亲进程的PID是1，因此，同chroot同样，若是咱们能够把用户的进程空间jail到某个进程分支下，并像chroot那样让其下面的进程 看到的那个超级父进程的PID为1，因而就能够达到资源隔离的效果了（不一样的PID namespace中的进程没法看到彼此）linux

šLinux Namespace 有以下种类，官方文档在这里《Namespace in Operation》docker

分类 系统调用参数 相关内核版本
Mount namespaces CLONE_NEWNS Linux 2.4.19
šUTS namespaces CLONE_NEWUTS Linux 2.6.19
IPC namespaces CLONE_NEWIPC Linux 2.6.19
PID namespaces CLONE_NEWPID Linux 2.6.24
Network namespaces CLONE_NEWNET 始于Linux 2.6.24 完成于 Linux 2.6.29
User namespaces CLONE_NEWUSER 始于 Linux 2.6.23 完成于 Linux 3.8)

主要是š三个系统调用shell

  • šclone() – 实现线程的系统调用，用来建立一个新的进程，并能够经过设计上述参数达到隔离。
  • šunshare() – 使某进程脱离某个namespace
  • šsetns() – 把某进程加入到某个namespace

unshare() 和 setns() 都比较简单，你们能够本身man，我这里不说了。编程

下面仍是让咱们来看一些示例（如下的测试程序最好在Linux 内核为3.8以上的版本中运行，我用的是ubuntu 14.04）。bootstrap

clone()系统调用

首先，咱们来看一下一个最简单的clone()系统调用的示例，（后面，咱们的程序都会基于这个程序作修改）：ubuntu

#define _GNU_SOURCE
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <sched.h>
#include <signal.h>
#include <unistd.h>
 
/* 定义一个给 clone 用的栈，栈大小1M */
#define STACK_SIZE (1024 * 1024)
static char container_stack[STACK_SIZE];
 
char* const container_args[] = {
    "/bin/bash",
    NULL
};
 
int container_main(void* arg)
{
    printf("Container - inside the container!\n");
    /* 直接执行一个shell，以便咱们观察这个进程空间里的资源是否被隔离了 */
    execv(container_args[0], container_args);
    printf("Something's wrong!\n");
    return 1;
}
 
int main()
{
    printf("Parent - start a container!\n");
    /* 调用clone函数，其中传出一个函数，还有一个栈空间的（为何传尾指针，由于栈是反着的） */
    int container_pid = clone(container_main, container_stack+STACK_SIZE, SIGCHLD, NULL);
    /* 等待子进程结束 */
    waitpid(container_pid, NULL, 0);
    printf("Parent - container stopped!\n");
    return 0;
}

从上面的程序，咱们能够看到，这和pthread基本上是同样的玩法。可是，对于上面的程序，父子进程的进程空间是没有什么差异的，父进程能访问到的子进程也能。

下面， 让咱们来看几个例子看看，Linux的Namespace是什么样的。

UTS Namespace

下面的代码，我略去了上面那些头文件和数据结构的定义，只有最重要的部分。

int container_main(void* arg)
{
    printf("Container - inside the container!\n");
    sethostname("container",10); /* 设置hostname */
    execv(container_args[0], container_args);
    printf("Something's wrong!\n");
    return 1;
}
 
int main()
{
    printf("Parent - start a container!\n");
    int container_pid = clone(container_main, container_stack+STACK_SIZE,
            CLONE_NEWUTS | SIGCHLD, NULL); /*启用CLONE_NEWUTS Namespace隔离 */
    waitpid(container_pid, NULL, 0);
    printf("Parent - container stopped!\n");
    return 0;
}

　　

运行上面的程序你会发现（须要root权限），子进程的hostname变成了 container。

hchen@ubuntu:~$ sudo ./uts
Parent - start a container!
Container - inside the container!
root@container:~# hostname
container
root@container:~# uname -n
container

IPC Namespace

IPC全称 Inter-Process Communication，是Unix/Linux下进程间通讯的一种方式，IPC有共享内存、信号量、消息队列等方法。因此，为了隔离，咱们也须要把IPC给隔离开来，这样，只有在同一个Namespace下的进程才能相互通讯。若是你熟悉IPC的原理的话，你会知道，IPC须要有一个全局的ID，即然是全局的，那么就意味着咱们的Namespace须要对这个ID隔离，不能让别的Namespace的进程看到。

要启动IPC隔离，咱们只须要在调用clone时加上CLONE_NEWIPC参数就能够了。

int container_pid = clone(container_main, container_stack+STACK_SIZE, 
            CLONE_NEWUTS | CLONE_NEWIPC | SIGCHLD, NULL);

首先，咱们先建立一个IPC的Queue（以下所示，全局的Queue ID是0）

hchen@ubuntu:~$ ipcmk -Q
Message queue id: 0
 
hchen@ubuntu:~$ ipcs -q
------ Message Queues --------
key        msqid      owner      perms      used-bytes   messages    
0xd0d56eb2 0          hchen      644        0            0

若是咱们运行没有CLONE_NEWIPC的程序，咱们会看到，在子进程中仍是能看到这个全启的IPC Queue。

hchen@ubuntu:~$ sudo ./uts
Parent - start a container!
Container - inside the container!
 
root@container:~# ipcs -q
 
------ Message Queues --------
key        msqid      owner      perms      used-bytes   messages    
0xd0d56eb2 0          hchen      644        0            0

可是，若是咱们运行加上了CLONE_NEWIPC的程序，咱们就会下面的结果：

root@ubuntu:~$ sudo./ipc
Parent - start a container!
Container - inside the container!
 
root@container:~/linux_namespace# ipcs -q
 
------ Message Queues --------
key        msqid      owner      perms      used-bytes   messages

咱们能够看到IPC已经被隔离了。

PID Namespace

咱们继续修改上面的程序：

int container_main(void* arg)
{
    /* 查看子进程的PID，咱们能够看到其输出子进程的 pid 为 1 */
    printf("Container [%5d] - inside the container!\n", getpid());
    sethostname("container",10);
    execv(container_args[0], container_args);
    printf("Something's wrong!\n");
    return 1;
}
 
int main()
{
    printf("Parent [%5d] - start a container!\n", getpid());
    /*启用PID namespace - CLONE_NEWPID*/
    int container_pid = clone(container_main, container_stack+STACK_SIZE, 
            CLONE_NEWUTS | CLONE_NEWPID | SIGCHLD, NULL);
    waitpid(container_pid, NULL, 0);
    printf("Parent - container stopped!\n");
    return 0;
}

运行结果以下（咱们能够看到，子进程的pid是1了）：

hchen@ubuntu:~$ sudo ./pid
Parent [ 3474] - start a container!
Container [    1] - inside the container!
root@container:~# echo $$
1

你可能会问，PID为1有个毛用啊？咱们知道，在传统的UNIX系统中，PID为1的进程是init，地位很是特殊。他做为全部进程的父进程，有不少特权（好比：屏蔽信号等），另外，其还会为检查全部进程的状态，咱们知道，若是某个子进程脱离了父进程（父进程没有wait它），那么init就会负责回收资源并结束这个子进程。因此，要作到进程空间的隔离，首先要建立出PID为1的进程，最好就像chroot那样，把子进程的PID在容器内变成1。

可是，咱们会发现，在子进程的shell里输入ps,top等命令，咱们仍是能够看获得全部进程。说明并无彻底隔离。这是由于，像ps, top这些命令会去读/proc文件系统，因此，由于/proc文件系统在父进程和子进程都是同样的，因此这些命令显示的东西都是同样的。

因此，咱们还须要对文件系统进行隔离。

Mount Namespace

下面的例程中，咱们在启用了mount namespace并在子进程中从新mount了/proc文件系统。

int container_main(void* arg)
{
    printf("Container [%5d] - inside the container!\n", getpid());
    sethostname("container",10);
    /* 从新mount proc文件系统到 /proc下 */
    system("mount -t proc proc /proc");
    execv(container_args[0], container_args);
    printf("Something's wrong!\n");
    return 1;
}
 
int main()
{
    printf("Parent [%5d] - start a container!\n", getpid());
    /* 启用Mount Namespace - 增长CLONE_NEWNS参数 */
    int container_pid = clone(container_main, container_stack+STACK_SIZE, 
            CLONE_NEWUTS | CLONE_NEWPID | CLONE_NEWNS | SIGCHLD, NULL);
    waitpid(container_pid, NULL, 0);
    printf("Parent - container stopped!\n");
    return 0;
}

运行结果以下：

hchen@ubuntu:~$ sudo ./pid.mnt
Parent [ 3502] - start a container!
Container [    1] - inside the container!
root@container:~# ps -elf
F S UID        PID  PPID  C PRI  NI ADDR SZ WCHAN  STIME TTY          TIME CMD
4 S root         1     0  0  80   0 -  6917 wait   19:55 pts/2    00:00:00 /bin/bash
0 R root        14     1  0  80   0 -  5671 -      19:56 pts/2    00:00:00 ps -elf

上面，咱们能够看到只有两个进程 ，并且pid=1的进程是咱们的/bin/bash。咱们还能够看到/proc目录下也干净了不少：

root@container:~# ls /proc
1          dma          key-users   net            sysvipc
16         driver       kmsg        pagetypeinfo   timer_list
acpi       execdomains  kpagecount  partitions     timer_stats
asound     fb           kpageflags  sched_debug    tty
buddyinfo  filesystems  loadavg     schedstat      uptime
bus        fs           locks       scsi           version
cgroups    interrupts   mdstat      self           version_signature
cmdline    iomem        meminfo     slabinfo       vmallocinfo
consoles   ioports      misc        softirqs       vmstat
cpuinfo    irq          modules     stat           zoneinfo
crypto     kallsyms     mounts      swaps
devices    kcore        mpt         sys
diskstats  keys         mtrr        sysrq-trigger

下图，咱们也能够看到在子进程中的top命令只看获得两个进程了。

这里，多说一下。在经过CLONE_NEWNS建立mount namespace后，父进程会把本身的文件结构复制给子进程中。而子进程中新的namespace中的全部mount操做都只影响自身的文件系统，而不对外界产生任何影响。这样能够作到比较严格地隔离。

 

你可能会问，咱们是否是还有别的一些文件系统也须要这样mount? 是的。

Docker的 Mount Namespace

下面我将向演示一个“山寨镜像”，其模仿了Docker的Mount Namespace。

首先，咱们须要一个rootfs，也就是咱们须要把咱们要作的镜像中的那些命令什么的copy到一个rootfs的目录下，咱们模仿Linux构建以下的目录：

hchen@ubuntu:~/rootfs$ ls
bin  dev  etc  home  lib  lib64  mnt  opt  proc  root  run  sbin  sys  tmp  usr  var

而后，咱们把一些咱们须要的命令copy到 rootfs/bin目录中（sh命令必须要copy进去，否则咱们没法 chroot ）

hchen@ubuntu:~/rootfs$ ls ./bin ./usr/bin
  
./bin:
bash   chown  gzip      less  mount       netstat  rm     tabs  tee      top       tty
cat    cp     hostname  ln    mountpoint  ping     sed    tac   test     touch     umount
chgrp  echo   ip        ls    mv          ps       sh     tail  timeout  tr        uname
chmod  grep   kill      more  nc          pwd      sleep  tar   toe      truncate  which
 
./usr/bin:
awk  env  groups  head  id  mesg  sort  strace  tail  top  uniq  vi  wc  xargs

注：你可使用ldd命令把这些命令相关的那些so文件copy到对应的目录：

hchen@ubuntu:~/rootfs/bin$ ldd bash
    linux-vdso.so.1 =>  (0x00007fffd33fc000)
    libtinfo.so.5 => /lib/x86_64-linux-gnu/libtinfo.so.5 (0x00007f4bd42c2000)
    libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007f4bd40be000)
    libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f4bd3cf8000)
    /lib64/ld-linux-x86-64.so.2 (0x00007f4bd4504000)

下面是个人rootfs中的一些so文件：

hchen@ubuntu:~/rootfs$ ls ./lib64 ./lib/x86_64-linux-gnu/
 
./lib64:
ld-linux-x86-64.so.2
 
./lib/x86_64-linux-gnu/:
libacl.so.1      libmemusage.so         libnss_files-2.19.so    libpython3.4m.so.1
libacl.so.1.1.0  libmount.so.1          libnss_files.so.2       libpython3.4m.so.1.0
libattr.so.1     libmount.so.1.1.0      libnss_hesiod-2.19.so   libresolv-2.19.so
libblkid.so.1    libm.so.6              libnss_hesiod.so.2      libresolv.so.2
libc-2.19.so     libncurses.so.5        libnss_nis-2.19.so      libselinux.so.1
libcap.a         libncurses.so.5.9      libnss_nisplus-2.19.so  libtinfo.so.5
libcap.so        libncursesw.so.5       libnss_nisplus.so.2     libtinfo.so.5.9
libcap.so.2      libncursesw.so.5.9     libnss_nis.so.2         libutil-2.19.so
libcap.so.2.24   libnsl-2.19.so         libpcre.so.3            libutil.so.1
libc.so.6        libnsl.so.1            libprocps.so.3          libuuid.so.1
libdl-2.19.so    libnss_compat-2.19.so  libpthread-2.19.so      libz.so.1
libdl.so.2       libnss_compat.so.2     libpthread.so.0
libgpm.so.2      libnss_dns-2.19.so     libpython2.7.so.1
libm-2.19.so     libnss_dns.so.2        libpython2.7.so.1.0

包括这些命令依赖的一些配置文件：

hchen@ubuntu:~/rootfs$ ls ./etc
bash.bashrc  group  hostname  hosts  ld.so.cache  nsswitch.conf  passwd  profile  
resolv.conf  shadow

你如今会说，我靠，有些配置我但愿是在容器起动时给他设置的，而不是hard code在镜像中的。好比：/etc/hosts，/etc/hostname，还有DNS的/etc/resolv.conf文件。好的。那咱们在rootfs外面，咱们再建立一个conf目录，把这些文件放到这个目录中。

hchen@ubuntu:~$ ls ./conf
hostname     hosts     resolv.conf

这样，咱们的父进程就能够动态地设置容器须要的这些文件的配置， 而后再把他们mount进容器，这样，容器的镜像中的配置就比较灵活了。

好了，终于到了咱们的程序。

 

sudo运行上面的程序，你会看到下面的挂载信息以及一个所谓的“镜像”：

hchen@ubuntu:~$ sudo ./mount
Parent [ 4517] - start a container!
Container [    1] - inside the container!
root@container:/# mount
proc on /proc type proc (rw,relatime)
sysfs on /sys type sysfs (rw,relatime)
none on /tmp type tmpfs (rw,relatime)
udev on /dev type devtmpfs (rw,relatime,size=493976k,nr_inodes=123494,mode=755)
devpts on /dev/pts type devpts (rw,relatime,mode=600,ptmxmode=000)
tmpfs on /run type tmpfs (rw,relatime)
/dev/disk/by-uuid/18086e3b-d805-4515-9e91-7efb2fe5c0e2 on /etc/hosts type ext4 (rw,relatime,errors=remount-ro,data=ordered)
/dev/disk/by-uuid/18086e3b-d805-4515-9e91-7efb2fe5c0e2 on /etc/hostname type ext4 (rw,relatime,errors=remount-ro,data=ordered)
/dev/disk/by-uuid/18086e3b-d805-4515-9e91-7efb2fe5c0e2 on /etc/resolv.conf type ext4 (rw,relatime,errors=remount-ro,data=ordered)
 
root@container:/# ls /bin /usr/bin
/bin:
bash   chmod  echo  hostname  less  more    mv   ping  rm   sleep  tail  test     top    truncate  uname
cat    chown  grep  ip        ln    mount   nc   ps    sed  tabs   tar   timeout  touch  tty       which
chgrp  cp     gzip  kill      ls    mountpoint  netstat  pwd   sh   tac    tee   toe      tr     umount
 
/usr/bin:
awk  env  groups  head  id  mesg  sort  strace  tail  top  uniq  vi  wc  xargs

关于如何作一个chroot的目录，这里有个工具叫DebootstrapChroot，你能够顺着连接去看看（英文的哦）

接下来的事情，你能够本身玩了，我相信你的想像力 。：）

在下一篇，我将向你介绍User Namespace、Network Namespace以及Namespace的其它东西。

 

摘自：https://coolshell.cn/articles/17010.html

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程