成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看

Docker 基礎技術：Linux Namespace（下）

作者：陳皓
運維 系統運維
在今天的這篇文章中，主要想向大家介紹Linux的User和Network的Namespace。

[[171780]]

在 Docker基礎技術：Linux Namespace(上篇)中我們了解了，UTD、IPC、PID、Mount 四個namespace，我們模仿Docker做了一個相當相當山寨的鏡像。在這一篇中，主要想向大家介紹Linux的User和Network的Namespace。

好，下面我們就介紹一下還剩下的這兩個Namespace。

User Namespace

User Namespace主要是用了CLONE_NEWUSER的參數。使用了這個參數后，內部看到的UID和GID已經與外部不同了，默認顯示為65534。那是因為容器找不到其真正的UID所以，設置上了最大的UID(其設置定義在/proc/sys/kernel/overflowuid)。

要把容器中的uid和真實系統的uid給映射在一起，需要修改 /proc/ /uid_map 和/proc/ /gid_map 這兩個文件。這兩個文件的格式為：

ID-inside-ns ID-outside-ns length

其中：

  • 第一個字段ID-inside-ns表示在容器顯示的UID或GID，
  • 第二個字段ID-outside-ns表示容器外映射的真實的UID或GID。
  • 第三個字段表示映射的范圍，一般填1，表示一一對應。

比如，把真實的uid=1000映射成容器內的uid=0

  1. $cat/proc/2465/uid_map 
  2.          0       1000          1 

再比如下面的示例：表示把namespace內部從0開始的uid映射到外部從0開始的uid，其最大范圍是無符號32位整形

  1. $cat/proc/$$/uid_map 
  2.          0          0          4294967295 

另外，需要注意的是：

  • 寫這兩個文件的進程需要這個namespace中的CAP_SETUID (CAP_SETGID)權限(可參看Capabilities)
  • 寫入的進程必須是此user namespace的父或子的user namespace進程。
  • 另外需要滿如下條件之一：1)父進程將effective uid/gid映射到子進程的user namespace中，2)父進程如果有CAP_SETUID/CAP_SETGID權限，那么它將可以映射到父進程中的任一uid/gid。

這些規則看著都煩，我們來看程序吧(下面的程序有點長，但是非常簡單，如果你讀過《Unix網絡編程》上卷，你應該可以看懂)：

  1. #define _GNU_SOURCE 
  2. #include <stdio.h> 
  3. #include <stdlib.h> 
  4. #include <sys/types.h> 
  5. #include <sys/wait.h> 
  6. #include <sys/mount.h> 
  7. #include <sys/capability.h> 
  8. #include <stdio.h> 
  9. #include <sched.h> 
  10. #include <signal.h> 
  11. #include <unistd.h> 
  12. #define STACK_SIZE (1024 * 1024) 
  13. staticcharcontainer_stack[STACK_SIZE]; 
  14. char*constcontainer_args[] = { 
  15.     “/bin/bash”, 
  16.     NULL 
  17. }; 
  18. intpipefd[2]; 
  19. voidset_map(char* file,intinside_id,intoutside_id,intlen) { 
  20.     FILE* mapfd =fopen(file,”w”); 
  21.     if(NULL == mapfd) { 
  22.         perror(“open file error”); 
  23.         return; 
  24.     } 
  25.     fprintf(mapfd,”%d %d %d”, inside_id, outside_id, len); 
  26.     fclose(mapfd); 
  27. } 
  28. voidset_uid_map(pid_t pid,intinside_id,intoutside_id,intlen) { 
  29.     charfile[256]; 
  30.     sprintf(file,”/proc/%d/uid_map”, pid); 
  31.     set_map(file, inside_id, outside_id, len); 
  32. } 
  33. voidset_gid_map(pid_t pid,intinside_id,intoutside_id,intlen) { 
  34.     charfile[256]; 
  35.     sprintf(file,”/proc/%d/gid_map”, pid); 
  36.     set_map(file, inside_id, outside_id, len); 
  37. } 
  38. intcontainer_main(void* arg) 
  39. { 
  40.     printf(“Container [%5d] – inside the container!\n”, getpid()); 
  41.     printf(“Container: eUID = %ld;  eGID = %ld, UID=%ld, GID=%ld\n”, 
  42.             (long) geteuid(), (long) getegid(), (long) getuid(), (long) getgid()); 
  43.     /* 等待父進程通知后再往下執行（進程間的同步） */ 
  44.     charch; 
  45.     close(pipefd[1]); 
  46.     read(pipefd[0], &ch, 1); 
  47.     printf(“Container [%5d] – setup hostname!\n”, getpid()); 
  48.     //set hostname 
  49.     sethostname(“container”,10); 
  50.     //remount “/proc” to make sure the “top” and “ps” show container’s information 
  51.     mount(“proc”,”/proc”,”proc”, 0, NULL); 
  52.     execv(container_args[0], container_args); 
  53.     printf(“Something’s wrong!\n”); 
  54.     return1; 
  55. } 
  56. intmain() 
  57. { 
  58.     constintgid=getgid(), uid=getuid(); 
  59.     printf(“Parent: eUID = %ld;  eGID = %ld, UID=%ld, GID=%ld\n”, 
  60.             (long) geteuid(), (long) getegid(), (long) getuid(), (long) getgid()); 
  61.     pipe(pipefd); 
  62.     printf(“Parent [%5d] – start a container!\n”, getpid()); 
  63.     intcontainer_pid = clone(container_main, container_stack+STACK_SIZE, 
  64.             CLONE_NEWUTS | CLONE_NEWPID | CLONE_NEWNS | CLONE_NEWUSER | SIGCHLD, NULL); 
  65.     printf(“Parent [%5d] – Container [%5d]!\n”, getpid(), container_pid); 
  66.     //To map the uid/gid, 
  67.     //   we need edit the /proc/PID/uid_map (or /proc/PID/gid_map) in parent 
  68.     //The file format is 
  69.     //   ID-inside-ns   ID-outside-ns   length 
  70.     //if no mapping, 
  71.     //   the uid will be taken from /proc/sys/kernel/overflowuid 
  72.     //   the gid will be taken from /proc/sys/kernel/overflowgid 
  73.     set_uid_map(container_pid, 0, uid, 1); 
  74.     set_gid_map(container_pid, 0, gid, 1); 
  75.     printf(“Parent [%5d] – user/group mapping done!\n”, getpid()); 
  76.     /* 通知子進程 */ 
  77.     close(pipefd[1]); 
  78.     waitpid(container_pid, NULL, 0); 
  79.     printf(“Parent – container stopped!\n”); 
  80.     return0; 
  81. } 

上面的程序，我們用了一個pipe來對父子進程進行同步，為什么要這樣做?因為子進程中有一個execv的系統調用，這個系統調用會把當前子進程的進程空間給全部覆蓋掉，我們希望在execv之前就做好user namespace的uid/gid的映射，這樣，execv運行的/bin/bash就會因為我們設置了uid為0的inside-uid而變成#號的提示符。

整個程序的運行效果如下：

  1. hchen@ubuntu:~$id 
  2. uid=1000(hchen) gid=1000(hchen)groups=1000(hchen) 
  3. hchen@ubuntu:~$ ./user#<–以hchen用戶運行 
  4. Parent: eUID = 1000;  eGID = 1000, UID=1000, GID=1000 
  5. Parent [ 3262] – start a container! 
  6. Parent [ 3262] – Container [ 3263]! 
  7. Parent [ 3262] – user/groupmappingdone! 
  8. Container [    1] – inside the container! 
  9. Container: eUID = 0;  eGID = 0, UID=0, GID=0#<—Container里的UID/GID都為0了 
  10. Container [    1] – setuphostname! 
  11. root@container:~# id #<—-我們可以看到容器里的用戶和命令行提示符是root用戶了 
  12. uid=0(root) gid=0(root)groups=0(root),65534(nogroup) 

雖然容器里是root，但其實這個容器的/bin/bash進程是以一個普通用戶hchen來運行的。這樣一來，我們容器的安全性會得到提高。

我們注意到，User Namespace是以普通用戶運行，但是別的Namespace需要root權限，那么，如果我要同時使用多個Namespace，該怎么辦呢?一般來說，我們先用一般用戶創建User Namespace，然后把這個一般用戶映射成root，在容器內用root來創建其它的Namesapce。

Network Namespace

Network的Namespace比較啰嗦。在Linux下，我們一般用ip命令創建Network Namespace(Docker的源碼中，它沒有用ip命令，而是自己實現了ip命令內的一些功能——是用了Raw Socket發些“奇怪”的數據，呵呵)。這里，我還是用ip命令講解一下。

首先，我們先看個圖，下面這個圖基本上就是Docker在宿主機上的網絡示意圖(其中的物理網卡并不準確，因為docker可能會運行在一個VM中，所以，這里所謂的“物理網卡”其實也就是一個有可以路由的IP的網卡)

 

 

上圖中，Docker使用了一個私有網段，172.40.1.0，docker還可能會使用10.0.0.0和192.168.0.0這兩個私有網段，關鍵看你的路由表中是否配置了，如果沒有配置，就會使用，如果你的路由表配置了所有私有網段，那么docker啟動時就會出錯了。

當你啟動一個Docker容器后，你可以使用ip link show或ip addr show來查看當前宿主機的網絡情況(我們可以看到有一個docker0，還有一個veth22a38e6的虛擬網卡——給容器用的)：

  1. hchen@ubuntu:~$ ip link show 
  2. 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state … 
  3.     link/loopback00:00:00:00:00:00 brd 00:00:00:00:00:00 
  4. 2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc … 
  5.     link/ether00:0c:29:b7:67:7d brd ff:ff:ff:ff:ff:ff 
  6. 3: docker0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 … 
  7.     link/ether56:84:7a:fe:97:99 brd ff:ff:ff:ff:ff:ff 
  8. 5: veth22a38e6: <BROADCAST,UP,LOWER_UP> mtu 1500 qdisc … 
  9.     link/ether8e:30:2a:ac:8c:d1 brd ff:ff:ff:ff:ff:ff 

那么，要做成這個樣子應該怎么辦呢?我們來看一組命令：

  1. ## 首先，我們先增加一個網橋lxcbr0，模仿docker0 
  2. brctl addbr lxcbr0 
  3. brctl stp lxcbr0 off 
  4. ifconfiglxcbr0 192.168.10.1/24up#為網橋設置IP地址 
  5. ## 接下來，我們要創建一個network namespace – ns1 
  6. # 增加一個namesapce 命令為 ns1 （使用ip netns add命令） 
  7. ip netns add ns1 
  8. # 激活namespace中的loopback，即127.0.0.1（使用ip netns exec ns1來操作ns1中的命令） 
  9. ip netnsexecns1   ip linksetdev lo up 
  10. ## 然后，我們需要增加一對虛擬網卡 
  11. # 增加一個pair虛擬網卡，注意其中的veth類型，其中一個網卡要按進容器中 
  12. ip link add veth-ns1typeveth peer name lxcbr0.1 
  13. # 把 veth-ns1 按到namespace ns1中，這樣容器中就會有一個新的網卡了 
  14. ip linksetveth-ns1 netns ns1 
  15. # 把容器里的 veth-ns1改名為 eth0 （容器外會沖突，容器內就不會了） 
  16. ip netnsexecns1  ip linksetdev veth-ns1 name eth0 
  17. # 為容器中的網卡分配一個IP地址，并激活它 
  18. ip netnsexecns1ifconfigeth0 192.168.10.11/24up 
  19. # 上面我們把veth-ns1這個網卡按到了容器中，然后我們要把lxcbr0.1添加上網橋上 
  20. brctl addif lxcbr0 lxcbr0.1 
  21. # 為容器增加一個路由規則，讓容器可以訪問外面的網絡 
  22. ip netnsexecns1     ip route add default via 192.168.10.1 
  23. # 在/etc/netns下創建network namespce名稱為ns1的目錄， 
  24. # 然后為這個namespace設置resolv.conf，這樣，容器內就可以訪問域名了 
  25. mkdir-p/etc/netns/ns1 
  26. echo”nameserver 8.8.8.8″>/etc/netns/ns1/resolv.conf 

上面基本上就是docker網絡的原理了，只不過，

了解了這些后，你甚至可以為正在運行的docker容器增加一個新的網卡：

  1.      
  2. ip link add peerAtypeveth peer name peerB 
  3. brctl addif docker0 peerA 
  4. ip linksetpeerA up 
  5. ip linksetpeerB netns ${container-pid} 
  6. ip netnsexec${container-pid} ip linksetdev peerB name eth1 
  7. ip netnsexec${container-pid} ip linkseteth1 up ; 
  8. ip netnsexec${container-pid} ip addr add ${ROUTEABLE_IP} dev eth1 ; 

上面的示例是我們為正在運行的docker容器，增加一個eth1的網卡，并給了一個靜態的可被外部訪問到的IP地址。

這個需要把外部的“物理網卡”配置成混雜模式，這樣這個eth1網卡就會向外通過ARP協議發送自己的Mac地址，然后外部的交換機就會把到這個IP地址的包轉到“物理網卡”上，因為是混雜模式，所以eth1就能收到相關的數據，一看，是自己的，那么就收到。這樣，Docker容器的網絡就和外部通了。

當然，無論是Docker的NAT方式，還是混雜模式都會有性能上的問題，NAT不用說了，存在一個轉發的開銷，混雜模式呢，網卡上收到的負載都會完全交給所有的虛擬網卡上，于是就算一個網卡上沒有數據，但也會被其它網卡上的數據所影響。

這兩種方式都不夠完美，我們知道，真正解決這種網絡問題需要使用VLAN技術，于是Google的同學們為Linux內核實現了一個IPVLAN的驅動，這基本上就是為Docker量身定制的。

Namespace文件

上面就是目前Linux Namespace的玩法。 現在，我來看一下其它的相關東西。

讓我們運行一下上篇中的那個pid.mnt的程序(也就是PID Namespace中那個mount proc的程序)，然后不要退出。

  1. $ sudo ./pid.mnt 
  2. [sudo] passwordforhchen: 
  3. Parent [ 4599] – start a container! 
  4. Container [    1] – inside the container! 

我們到另一個shell中查看一下父子進程的PID：

  1. hchen@ubuntu:~$ pstree -p 4599 
  2. pid.mnt(4599)───bash(4600) 

我們可以到proc下(/proc//ns)查看進程的各個namespace的id(內核版本需要3.8以上)。

下面是父進程的：

  1. hchen@ubuntu:~$sudols-l/proc/4599/ns 
  2. total 0 
  3. lrwxrwxrwx 1 root root 0  4月  7 22:01 ipc -> ipc:[4026531839] 
  4. lrwxrwxrwx 1 root root 0  4月  7 22:01 mnt -> mnt:[4026531840] 
  5. lrwxrwxrwx 1 root root 0  4月  7 22:01 net -> net:[4026531956] 
  6. lrwxrwxrwx 1 root root 0  4月  7 22:01 pid -> pid:[4026531836] 
  7. lrwxrwxrwx 1 root root 0  4月  7 22:01 user -> user:[4026531837] 
  8. lrwxrwxrwx 1 root root 0  4月  7 22:01 uts -> uts:[4026531838] 

下面是子進程的：

  1. hchen@ubuntu:~$sudols-l/proc/4600/ns 
  2. total 0 
  3. lrwxrwxrwx 1 root root 0  4月  7 22:01 ipc -> ipc:[4026531839] 
  4. lrwxrwxrwx 1 root root 0  4月  7 22:01 mnt -> mnt:[4026532520] 
  5. lrwxrwxrwx 1 root root 0  4月  7 22:01 net -> net:[4026531956] 
  6. lrwxrwxrwx 1 root root 0  4月  7 22:01 pid -> pid:[4026532522] 
  7. lrwxrwxrwx 1 root root 0  4月  7 22:01 user -> user:[4026531837] 
  8. lrwxrwxrwx 1 root root 0  4月  7 22:01 uts -> uts:[4026532521] 

我們可以看到，其中的ipc，net，user是同一個ID，而mnt,pid,uts都是不一樣的。如果兩個進程指向的namespace編號相同，就說明他們在同一個namespace下，否則則在不同namespace里面。

這些文件還有另一個作用，那就是，一旦這些文件被打開，只要其fd被占用著，那么就算PID所屬的所有進程都已經結束，創建的namespace也會一直存在。比如：我們可以通過：mount –bind /proc/4600/ns/uts ~/uts 來hold這個namespace。

另外，我們在上篇中講過一個setns的系統調用，其函數聲明如下：

  1. intsetns(intfd,intnstype); 

其中第一個參數就是一個fd，也就是一個open()系統調用打開了上述文件后返回的fd，比如：

  1. fd = open(“/proc/4600/ns/nts”, O_RDONLY); // 獲取namespace文件描述符 
  2. setns(fd, 0);// 加入新的namespace 
責任編輯：趙寧寧 來源： H2EX
Docker Linux Namespace
相關推薦

2016-09-20 21:32:16

DockerLinux Names

2021-07-10 08:29:13

Docker內核Namespace

2021-07-14 10:33:22

Docker內核Mount Names

2022-08-04 07:25:22

Docker部署項目

2010-01-11 10:17:12

2015-08-26 11:27:26

DockerDeviceMappe分層鏡像

2018-12-20 10:55:29

2022-07-21 11:58:12

Docker

2011-04-07 15:02:02

LinuxMySQL數據庫

2014-09-18 14:13:54

Docker

2021-03-05 18:36:00

Linux網橋Docker

2024-02-23 10:11:00

虛擬化技術

2022-08-30 19:11:12

Docker虛擬化技術

2021-02-03 11:20:41

Docker架構容器

2024-01-10 14:24:32

Docker容器Kafka

2021-01-09 09:20:08

Linux發行版Docker

2009-07-04 20:16:50

2023-09-02 20:34:04

2022-07-26 07:14:52

Docker宿主命令

2018-08-06 08:51:32

Linux命令cut
點贊
收藏

51CTO技術棧公眾號

主站蜘蛛池模板： 免费在线观看一区二区三区 | aa级毛片毛片免费观看久 | 久久伊人精品 | 成人一区二区视频 | 成人不卡一区二区 | 99久久久久久 | 在线日韩视频 | 国产精品高清在线 | 亚洲成人激情在线观看 | 国产精品久久久久久久久久久久 | 日韩在线一区二区 | 日韩精品在线视频免费观看 | 国产精品久久久久久婷婷天堂 | 国产精品美女久久久久久免费 | 玖玖爱365| 亚洲欧洲一区二区 | 久久久久国产精品一区二区 | 免费在线h视频 | 黄色免费在线观看 | 亚洲一区二区三区四区五区午夜 | 一区在线观看视频 | 草b视频| 九九伦理电影 | 欧美日韩成人在线观看 | 黄在线免费观看 | 在线2区| 精久久 | av黄色在线| 日韩1区| 久草免费福利 | 男人天堂色 | 中文字幕乱码一区二区三区 | 日韩欧美国产精品一区 | 天堂影院av | 精品一区二区三区在线观看 | 日韩1区2区 | 一区二区三区亚洲 | 精产嫩模国品一二三区 | 亚洲一二三在线观看 | 亚洲精品av在线 | 国产精品一区一区 |