探索 Linux Namespace：Docker 隔离的神奇背后

来自：探索云原生 https://www.lixueduan.com

原文：https://www.lixueduan.com/posts/docker/03-container-core/

namespace-kind

在 深入理解 Docker 核心原理：Namespace、Cgroups 和 Rootfs 一文中我们分析了 Docker 是由三大核心技术实现的。

docker-core

今天就一起分析 Docker 三大核心技术之一的 Linux Namespace。

后续文章会演示如何从零实现一个简易的 Docker，这里先简单了解下 Docker 的核心原理。

更新记录

第一版：写于 2022-02-11

第二版：更新于 2023.11.03，迁移到公众号，重制了一下

当我们通过 docker run -it 启动并进入一个容器之后，会发现不论是进程、网络还是文件系统，好像都被隔离了,就像这样：

[root@docker cpu]# docker run -it busybox
/ # 
/ # ps
PID   USER     TIME  COMMAND1 root      0:00 sh7 root      0:00 ps
/ # ip a 
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue qlen 1000link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00inet 127.0.0.1/8 scope host lovalid_lft forever preferred_lft forever
120: eth0@if121: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ffinet 172.17.0.2/16 brd 172.17.255.255 scope global eth0valid_lft forever preferred_lft forever
/ # ls
bin    dev    etc    home   lib    lib64  proc   root   sys    tmp    usr    var
  • ps 命令看不到宿主机上的进程
  • ip 命令也只能看到容器内部的网卡
  • ls 命令看到的文件好像也和宿主机不一样

这就是 Docker 核心之一，借助 Linux Namespace 技术实现了视图隔离。

看起来容器和宿主机隔离开了

接下来就让我们一起探索一下 Linux Namespace 以及 Docker 是如何借助该能力来实现隔离的。

1. 什么是 Linux 命名空间（Namespace）？

Namespace 是 Linux 提供的一种内核级别环境隔离的方法。

可以使得处于不同 namespace 的进程拥有独立的全局系统资源，改变一个 namespace 中的系统资源只会影响当前 namespace 里的进程，对其他 namespace 中的进程没有影响。

简单来说：namespace 就是对资源的逻辑隔离

目前，Linux 内核里面实现了 8 种不同类型的 namespace：

namespace-kind

分类系统调用参数隔离内容相关内核版本
Mount namespacesCLONE_NEWNSMount pointsLinux 2.4.19
UTS namespacesCLONE_NEWUTSHostname and NIS domain nameLinux 2.6.19
IPC namespacesCLONE_NEWIPCSystem V IPC, POSIX message queuesLinux 2.6.19
PID namespacesCLONE_NEWPIDProcess IDsLinux 2.6.24
Network namespacesCLONE_NEWNETNetwork devices, stacks, ports, etc.始于Linux 2.6.24 完成于 Linux 2.6.29
User namespacesCLONE_NEWUSERUser and group IDs始于 Linux 2.6.23 完成于 Linux 3.8)
Cgroup namespaceCLONE_NEWCGROUPCgroup root directoryLinux 4.6
Time namespaceCLONE_NEWTIMEBoot and monotonicLinux 5.6

前面 6 种是比较常见的，后面两种 Cgroup Namespace 以及 Time Namespace 则是比较少见。

相关API

和 namespace 相关的函数只有四个，这里简单的看一下：

namespace-api

  • clone
  • setns
  • unshare
  • ioctl_ns

clone：创建一个新的进程并把他放到新的 namespace 中。

int clone(int (*fn)(void *), void *stack, int flags, void *arg, .../* pid_t *parent_tid, void *tls, pid_t *child_tid */ );/*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
*/

ioctl_ns：查询 namespace 信息。

new_fd = ioctl(fd, request);
/*
fd: 指向/proc/[pid]/ns/目录里相应namespace对应的文件
request: NS_GET_USERNS: 返回指向拥有用户的文件描述符namespace fd引用的命名空间NS_GET_PARENT: 返回引用父级的文件描述符由fd引用的命名空间的命名空间。
*/

看完之后大致可以这样分类：

  • clone、unshare：加入新 namespace
  • setsns：加入已有 namespace
  • ioctl_ns：主要用于查询

clone 和 unshare 都是加入新 namespace，二者有什么区别呢？

二者的功能都是创建并加入新的 namespace， 区别在于：

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

查看进程所属的 namespaces

系统中的每个进程都有 /proc/[pid]/ns/ 这样一个目录，里面包含了这个进程所属 namespace 的信息，里面每个文件的描述符都可以用来作为 setns 函数(后面会介绍)的参数。

#查看当前bash进程所属的namespacelixd  ~  ls -l /proc/$$/ns
total 0
lrwxrwxrwx 1 lixd lixd 0 Jan  6 19:00 cgroup -> 'cgroup:[4026531835]'
lrwxrwxrwx 1 lixd lixd 0 Jan  6 19:00 ipc -> 'ipc:[4026532227]'
lrwxrwxrwx 1 lixd lixd 0 Jan  6 19:00 mnt -> 'mnt:[4026532241]'
lrwxrwxrwx 1 lixd lixd 0 Jan  6 19:00 net -> 'net:[4026531992]'
lrwxrwxrwx 1 lixd lixd 0 Jan  6 19:00 pid -> 'pid:[4026532243]'
lrwxrwxrwx 1 lixd lixd 0 Jan  6 19:00 pid_for_children -> 'pid:[4026532243]'
lrwxrwxrwx 1 lixd lixd 0 Jan  6 19:00 user -> 'user:[4026531837]'
lrwxrwxrwx 1 lixd lixd 0 Jan  6 19:00 uts -> 'uts:[4026532242]

以ipc:[4026532227]为例，其中 ipc 是 namespace 的类型，4026532227 是 inode number。

如果两个进程的 ipc namespace 的 inode number一样，说明他们属于同一个 namespace。

这条规则对其他类型的 namespace 也同样适用。

namespace 数量限制与回收策略

linux 也限制了 namespace 的数量，不能无限制的创建 namespace，具体限制一般在 /proc/sys/user 目录中。具体如下：

$ tree /proc/sys/user/
/proc/sys/user/
├── max_cgroup_namespaces
├── max_inotify_instances
├── max_inotify_watches
├── max_ipc_namespaces
├── max_mnt_namespaces
├── max_net_namespaces
├── max_pid_namespaces
├── max_user_namespaces
└── max_uts_namespaces$ cat /proc/sys/user/max_pid_namespaces
6784

以看到，当前系统中 PID namespace 最多可以创建 6784 个。

既然数量有限制，那已经创建的 namespace 什么时候会被销毁回收呢？

规则还是比较好理解的：当一个 namespace 中的所有进程都结束或者移出该 namespace 时，该 namespace 将会被销毁。

这也解释了为什么没有创建 namespace 的 API，因为刚创建的 namespace 没有任何进程，立马就会被回收。

不过也有一些特殊情况，可以再没有进程的时候保留 namespace：

  • 存在打开的 FD，或者对 /proc/[pid]/ns/* 执行了 bind mount
  • 存在子 namespace
  • 它是一个拥有一个或多个非用户 namespace 的 namespace。
  • 它是一个 PID namespace，并且有一个进程通过 /proc/[pid]/ns/pid_for_children 符号链接引用了这个 namespace。
  • 它是一个 Time namespace，并且有一个进程通过 /proc/[pid]/ns/time_for_children 符号链接引用了这个 namespace。
  • 它是一个 IPC namespace，并且有一个 mqueue 文件系统的 mount 引用了该 namespace
  • 它是一个 PIDnamespace，并且有一个 proc 文件系统的 mount 引用了该 namespace

一句话描述：当 namespace 有被使用时就不会被回收，反之则会被回收。

2. 使用 Go 语言操作 Linux 命名空间示例

UTS Namespace

UTS Namespace主要用来隔离nodename和domainname两个系统标识。

在UTS Namespace里面，每个Namespace允许有自己的hostname.

以下程序展示了如何在 Go 中切换 UTS Namespace。

// 注: 运行时需要 root 权限。
func main() {cmd := exec.Command("bash")cmd.SysProcAttr = &syscall.SysProcAttr{Cloneflags: syscall.CLONE_NEWUTS,}cmd.Stdin = os.Stdincmd.Stdout = os.Stdoutcmd.Stderr = os.Stderrif err := cmd.Run(); err != nil {log.Fatalln(err)}
}

运行并测试

DESKTOP-9K4GB6E# go run main.go
root@DESKTOP-9K4GB6E:/home/lixd/projects/docker/mydocker#

运行后会进入了一个新的 shell 环境。

查看以下是否真的进入了新的 UTS Namespace。

首先使用 pstree查看进程关系：

root@DESKTOP-9K4GB6E:/home/lixd/projects/docker/mydocker# pstree -pl
init(1)─┬─init(1272)───init(1273)───server(1274)─┬─{server}(1282)│                                        ├─{server}(1283)│                                        ├─{server}(1284)│                                        ├─{server}(1285)│                                        ├─{server}(1286)│                                        ├─{server}(1287)│                                        ├─{server}(1288)│                                        └─{server}(1289)├─init(3701)───init(3702)───zsh(3703)───su(7520)───bash(7521)───zsh(7575)───go(8104)─┬─main(8182)─┬─bash(8187)───pstree(8194)│                                                                                    │            ├─{main}(8183)│                                                                                    │            ├─{main}(8184)│                                                                                    │            ├─{main}(8185)│                                                                                    │            └─{main}(8186)│                                                                                    ├─{go}(8105)│                                                                                    ├─{go}(8106)│                                                                                    ├─{go}(8107)│                                                                                    ├─{go}(8108)│                                                                                    ├─{go}(8109)│                                                                                    ├─{go}(8110)│                                                                                    ├─{go}(8111)│                                                                                    ├─{go}(8112)│                                                                                    ├─{go}(8117)│                                                                                    └─{go}(8143)├─init(3763)───init(3764)───zsh(3765)├─init(5171)───init(5172)───fsnotifier-wsl(5173)├─init(7459)───init(7460)───bash(7461)───su(7476)───bash(7477)├─{init}(5)└─{init}(6)

主要关注这条：

├─init(3701)───init(3702)───zsh(3703)───su(7520)───bash(7521)───zsh(7575)───go(8104)─┬─main(8182)─┬─bash(8187)

main 程序 pid 为 8182,后续新创建的 bash pid 为 8187，现在查看二者 uts 是否相同即可：

root@DESKTOP-9K4GB6E:/home/lixd/projects/docker/mydocker# readlink /proc/8182/ns/uts
uts:[4026532242]
root@DESKTOP-9K4GB6E:/home/lixd/projects/docker/mydocker# readlink /proc/8187/ns/uts
uts:[4026532386]

可以发现二者确实不在一个 UTS Namespace 中。由于 UTS Namespace hostname 做了隔离 所以在这个环境内修改 hostname 应该不影响外部主机， 下面来做 下实验。

在这个新的 bash 环境中修改 hostname

root@DESKTOP-9K4GB6E:/home/lixd/projects/docker/mydocker# hostname bash
root@DESKTOP-9K4GB6E:/home/lixd/projects/docker/mydocker# hostname
bash

新开一个在宿主机上查看 hostname：

 lixd  ~ $ hostname
DESKTOP-9K4GB6E

可以看到外部的 hostname 并没有被修改影响，由此可了解 UTS Namespace 的作用。

IPC Namespace

IPC Namespace 用来隔离 sys V IPC和 POSIX message queues。

每个 IPC Namespace 都有自己的 Sys V IPC 和 POSIX message queues。

微调一下程序，只是修改了 Cloneflags，新增了 CLONE_NEWIPC，表示同时创建 IPC Namespace。

// 注: 运行时需要 root 权限。
func main() {cmd := exec.Command("bash")cmd.SysProcAttr = &syscall.SysProcAttr{// Cloneflags: syscall.CLONE_NEWUTS,Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWIPC,}cmd.Stdin = os.Stdincmd.Stdout = os.Stdoutcmd.Stderr = os.Stderrif err := cmd.Run(); err != nil {log.Fatalln(err)}
}

运行并测试：

# 先查看宿主机上的 ipc message queue
DESKTOP-9K4GB6E# ipcs -q
------ Message Queues --------
key        msqid      owner      perms      used-bytes   messages# 然后创建一个 
DESKTOP-9K4GB6E# ipcmk -Q
Message queue id: 0
# 再次查看，发现有了
DESKTOP-9K4GB6E# ipcs -q
------ Message Queues --------
key        msqid      owner      perms      used-bytes   messages
0x70ffd07c 0          root       644        0            0

运行程序进入新的 shell

DESKTOP-9K4GB6E# go run main.go
root@DESKTOP-9K4GB6E:/home/lixd/projects/docker/mydocker# ipcs -q
------ Message Queues --------
key        msqid      owner      perms      used-bytes   messages

可以发现，在新的 Namespace 中已经看不到宿主机上的 message queue 了。说明 IPC Namespace 创建成功，IPC 已经被隔离。

PID Namespace

PID Namespace是用来隔离进程ID的。

同样一个进程在不同的PID Namespace里可以拥有不同的PID。

这样就可以理解，在docker container 里面，使用ps -ef经常会发现，在容器内，前台运行的那个进程PID是1，但是在容器外，使用ps -ef会发现同样的进程却有不同的PID，这就是PID Namespace做的事情。

再次调整程序，增加 PID flags：

// 注: 运行时需要 root 权限。
func main() {cmd := exec.Command("bash")cmd.SysProcAttr = &syscall.SysProcAttr{// Cloneflags: syscall.CLONE_NEWUTS,// Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWIPC,Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWIPC | syscall.CLONE_NEWPID,}cmd.Stdin = os.Stdincmd.Stdout = os.Stdoutcmd.Stderr = os.Stderrif err := cmd.Run(); err != nil {log.Fatalln(err)}
}

运行并测试：

DESKTOP-9K4GB6E# go run main.go
root@DESKTOP-9K4GB6E:/home/lixd/projects/docker/mydocker# pstree -pl
init(1)─┬─init(1272)───init(1273)───server(1274)─┬─{server}(1282)│                                        ├─{server}(1283)│                                        ├─{server}(1284)│                                        ├─{server}(1285)│                                        ├─{server}(1286)│                                        ├─{server}(1287)│                                        ├─{server}(1288)│                                        └─{server}(1289)├─init(3701)───init(3702)───zsh(3703)───su(7520)───bash(7521)───zsh(7575)───go(9103)─┬─main(9184)─┬─bash(9189)───pstree(9196)│                                                                                    │            ├─{main}(9185)│                                                                                    │            ├─{main}(9186)│                                                                                    │            ├─{main}(9187)│                                                                                    │            └─{main}(9188)│                                                                                    ├─{go}(9104)│                                                                                    ├─{go}(9105)│                                                                                    ├─{go}(9106)│                                                                                    ├─{go}(9107)│                                                                                    ├─{go}(9108)│                                                                                    ├─{go}(9109)│                                                                                    ├─{go}(9110)│                                                                                    ├─{go}(9111)│                                                                                    ├─{go}(9112)│                                                                                    └─{go}(9120)├─init(3763)───init(3764)───zsh(3765)├─init(5171)───init(5172)───fsnotifier-wsl(5173)├─init(7459)───init(7460)───bash(7461)───su(7476)───bash(7477)├─init(8201)───init(8202)───zsh(8203)├─{init}(5)└─{init}(6)

可以看到 main 函数 pid 为 9184，而新开的 bash pid 为 9189。

然后再新开的 bash 中查看自己的 pid：

这里只能使用 echo $$ 命令查看，ps、top 等命令会查看到其他 Namespace 中的信息。

root@DESKTOP-9K4GB6E:/home/lixd/projects/docker/mydocker# echo $$
1

发现 pid 是1，说明再新开的 PID Namespace 中只有一个 bash 这个进程，而且被伪装成了 1 号进程。

Mount Namespace

Mount Namespace用来隔离各个进程看到的挂载点视图。

在不同Namespace的进程中，看到的文件系统层次是不一样的。 在Mount Namespace中调用mount()和umount()仅仅只会影响当前Namespace内的文件系统，而对全局的文件系统是没有影响的。

看到这里，也许就会想到chroot()，它也是将某一个子目录变成根节点。但是，Mount Namespace不仅能实现这个功能，而且能以更加灵活和安全的方式实现。

需要注意的是，Mount Namespace 的 flag 是CLONE_NEWNS,直接是 NEWNS 而不是 NEWMOUNT,因为 Mount Namespace 是 Linux 中实现的第一个 Namespace，当时也没想到后续会有很多类型的 Namespace 加入。

再次修改代码，增加 Mount Namespace 的 flag

	cmd.SysProcAttr = &syscall.SysProcAttr{// Cloneflags: syscall.CLONE_NEWUTS,// Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWIPC,// Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWIPC | syscall.CLONE_NEWPID,Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWIPC | syscall.CLONE_NEWPID | syscall.CLONE_NEWNS,}

运行并测试：

首先运行程序并在新的 bash 环境中查看 /proc

DESKTOP-9K4GB6E# go run main.go
root@DESKTOP-9K4GB6E:/home/lixd/projects/docker/mydocker# ls /proc
1     3764  7476  9476       cmdline    driver       kallsyms     loadavg  net           swaps        vmallocinfo
1272  3765  7477  9557       config.gz  execdomains  kcore        locks    pagetypeinfo  sys          vmstat
1273  5171  7520  9562       consoles   filesystems  key-users    mdstat   partitions    sysvipc      zoneinfo
1274  5172  7521  9569       cpuinfo    fs           keys         meminfo  sched_debug   thread-self
3701  5173  7575  acpi       crypto     interrupts   kmsg         misc     schedstat     timer_list
3702  7459  8201  buddyinfo  devices    iomem        kpagecgroup  modules  self          tty
3703  7460  8202  bus        diskstats  ioports      kpagecount   mounts   softirqs      uptime
3763  7461  8203  cgroups    dma        irq          kpageflags   mtrr     stat          version

可以看到，有一大堆文件，这是因为现在查看到的其实是宿主机上的 /proc 目录。

现在把 proc 目录挂载到当前 Namespace 中来：

root@DESKTOP-9K4GB6E:/home/lixd/projects/docker/mydocker# mount -t proc proc /procroot@DESKTOP-9K4GB6E:/home/lixd/projects/docker/mydocker# ls /proc
1          cmdline    diskstats    interrupts  key-users    loadavg  mounts        schedstat  sysvipc      vmallocinfo
10         config.gz  dma          iomem       keys         locks    mtrr          self       thread-self  vmstat
acpi       consoles   driver       ioports     kmsg         mdstat   net           softirqs   timer_list   zoneinfo
buddyinfo  cpuinfo    execdomains  irq         kpagecgroup  meminfo  pagetypeinfo  stat       tty
bus        crypto     filesystems  kallsyms    kpagecount   misc     partitions    swaps      uptime
cgroups    devices    fs           kcore       kpageflags   modules  sched_debug   sys        version

可以看到，少了一些文件，少的主要是数字命名的目录，因为当前 Namespace 下没有这些进程，自然就看不到对应的信息了。

此时就可以通过 ps 命令来查看了：

root@DESKTOP-9K4GB6E:/home/lixd/projects/docker/mydocker# ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 13:13 pts/2    00:00:00 bash
root        11     1  0 13:13 pts/2    00:00:00 ps -ef

可以看到，在当前 Namespace 中 bash 为 1 号进程。

这就说明，当前 Mount Namespace 中的 mount 和外部是隔离的，mount 操作并没有影响到外部，Docker volume 也是利用了这个特性。

User Namespace

User Narespace 主要是隔离用户的用户组ID。

也就是说，一个进程的 UserID 和GroupID 在不同的 User Namespace 中可以是不同的。

比较常用的是，在宿主机上以一个非 root 用户运行创建一个 User Namespace, 然后在 User Namespace 里面却映射成 root 用户。这意味着，这个进程在 User Namespace 里面有 root 权限，但是在 User Namespace 外面却没有 root 的权限。

再次修改代码，增加 User Namespace 的 flag：

	cmd.SysProcAttr = &syscall.SysProcAttr{Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWIPC | syscall.CLONE_NEWPID | syscall.CLONE_NEWNS | syscall.CLONE_NEWUSER,}

运行并测试：

首先在宿主机上查看一个 user 和 group：

DESKTOP-9K4GB6E# id
uid=0(root) gid=0(root) groups=0(root)

可以看到，此时是 root 用户。

运行程序，进入新的 bash 环境：

DESKTOP-9K4GB6E# go run main.go
nobody@DESKTOP-9K4GB6E:/home/lixd/projects/docker/mydocker$ id
uid=65534(nobody) gid=65534(nogroup) groups=65534(nogroup)

可以看到，UID 是不同的，说明 User Namespace 生效了。

Network Namespace

Network Namespace 是用来隔离网络设备、IP 地址端口等网络栈的 Namespace。

Network Namespace 可以让每个容器拥有自己独立的(虛拟的)网络设备，而且容器内的应用可以绑定到自己的端口，每个 Namespace 内的端口都不会互相冲突。

在宿主机上搭建网桥后，就能很方便地实现容器之间的通信，而且不同容器上的应用可以使用相同的端口。

再次修改代码，增加 Network Namespace 的 flag：

	cmd.SysProcAttr = &syscall.SysProcAttr{Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWIPC | syscall.CLONE_NEWPID | syscall.CLONE_NEWNS | syscall.CLONE_NEWUSER | syscall.CLONE_NEWNET,}

运行并测试：

首先看一下宿主机上的网络设备：

DESKTOP-9K4GB6E# ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00inet 127.0.0.1/8 scope host lovalid_lft forever preferred_lft foreverinet6 ::1/128 scope hostvalid_lft forever preferred_lft forever
2: bond0: <BROADCAST,MULTICAST,MASTER> mtu 1500 qdisc noop state DOWN group default qlen 1000link/ether 22:2f:1f:8e:f7:72 brd ff:ff:ff:ff:ff:ff
3: dummy0: <BROADCAST,NOARP> mtu 1500 qdisc noop state DOWN group default qlen 1000link/ether 7e:46:8b:04:23:81 brd ff:ff:ff:ff:ff:ff
4: tunl0@NONE: <NOARP> mtu 1480 qdisc noop state DOWN group default qlen 1000link/ipip 0.0.0.0 brd 0.0.0.0
5: sit0@NONE: <NOARP> mtu 1480 qdisc noop state DOWN group default qlen 1000link/sit 0.0.0.0 brd 0.0.0.0
6: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000link/ether 00:15:5d:6e:f2:65 brd ff:ff:ff:ff:ff:ffinet 172.18.167.21/20 brd 172.18.175.255 scope global eth0valid_lft forever preferred_lft foreverinet6 fe80::215:5dff:fe6e:f265/64 scope linkvalid_lft forever preferred_lft forever

有 lo、eth0 等6 个设备。

然后运行程序：

DESKTOP-9K4GB6E# go run main.go
nobody@DESKTOP-9K4GB6E:/home/lixd/projects/docker/mydocker$ ip addr
1: lo: <LOOPBACK> mtu 65536 qdisc noop state DOWN group default qlen 1000link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
2: tunl0@NONE: <NOARP> mtu 1480 qdisc noop state DOWN group default qlen 1000link/ipip 0.0.0.0 brd 0.0.0.0
3: sit0@NONE: <NOARP> mtu 1480 qdisc noop state DOWN group default qlen 1000link/sit 0.0.0.0 brd 0.0.0.0

可以发现，新的 Namespace 中只有3个设备了，说明 Network Namespace 生效了。

3. 小结

  • 0）Docker 使用 namespace 进行隔离。
  • 1）Namespace 的本质：Linux Namespace 是 Linux 提供的一种内核级别环境隔离的方法，本质就是对全局系统资源的一种封装隔离。
  • 2）Namespace 的使用：Namespace API 一共 4个，最常用的就是 clone，而 Go 已经把 clone 调用给封装好了，使用时只需要传入不同参数即可控制创建不同 Namespace。

namespace-kind

namespace-api

4. 参考

  • overview of Linux namespaces
  • Namespaces in operation, part 1: namespaces overview
  • Linux namespaces
  • Linux_namespaces
  • DOCKER基础技术：LINUX NAMESPACE（上）
  • DOCKER基础技术：LINUX NAMESPACE（下）

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/212147.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

万界星空科技MES---制造企业的加工生产模式

万界星空科技MES---制造企业的加工生产模式

在现代制造业中&#xff0c;加工生产模式是制造企业组织和管理生产过程的重要方面。不同的加工模式适用于不同的生产需求和产品类型。其中流水型、离散型和混合型是三种常见的加工生产模式。1. 流水型加工模式 流水型加工模式是一种高度自动化的生产方式&#xff0c;适用于…
阅读更多...
JavaScript实现手写签名，可触屏手写，支持移动端与PC端双端保存

JavaScript实现手写签名，可触屏手写，支持移动端与PC端双端保存

目录 1.HTML模板 2.获取DOM元素和定义变量 3.创建两个canvas元素&#xff0c;并设置它们的宽度和高度 4.绑定触摸事件&#xff1a;touchstart, touchmove, touchend和click 5.实现触摸事件回调函数&#xff1a;startDrawing, draw和stopDrawing 6.实现绘制线段的函数&…
阅读更多...
【PyTorch】模型选择、欠拟合和过拟合

【PyTorch】模型选择、欠拟合和过拟合

文章目录 1. 理论介绍2. 实例解析2.1. 实例描述2.2. 代码实现2.2.1. 完整代码2.2.2. 输出结果 1. 理论介绍 将模型在训练数据上拟合的比在潜在分布中更接近的现象称为过拟合&#xff0c; 用于对抗过拟合的技术称为正则化。训练误差和验证误差都很严重&#xff0c; 但它们之间差…
阅读更多...
Java程序员，你掌握了多线程吗？（文末送书）

Java程序员，你掌握了多线程吗？（文末送书）

目录 01、多线程对于Java的意义02、为什么Java工程师必须掌握多线程03、Java多线程使用方式04、如何学好Java多线程送书规则 摘要&#xff1a;互联网的每一个角落&#xff0c;无论是大型电商平台的秒杀活动&#xff0c;社交平台的实时消息推送&#xff0c;还是在线视频平台的流…
阅读更多...
@德人合科技 | 数据透明加密防泄密系统\文件文档加密\设计图纸加密|源代码加密防泄密软件系统，——防止内部办公终端核心文件数据/资料外泄！

@德人合科技 | 数据透明加密防泄密系统\文件文档加密\设计图纸加密|源代码加密防泄密软件系统，——防止内部办公终端核心文件数据/资料外泄！

一款专业的数据防泄密管理系统&#xff0c;它采用了多种加密模式&#xff0c;包括透明加密、半透明加密和落地加密等&#xff0c;可以有效地保护企业的核心数据安全。 PC端访问地址&#xff1a; https://isite.baidu.com/site/wjz012xr/2eae091d-1b97-4276-90bc-6757c5dfedee …
阅读更多...
验证码的多种生成策略

验证码的多种生成策略

&#x1f60a; 作者&#xff1a; 瓶盖子io &#x1f496; 主页&#xff1a; 瓶盖子io-CSDN博客 第一种 a.导入依赖 <dependency><groupId>org.apache.commons</groupId><artifactId>commons-lang3</artifactId><version>3.10</ver…
阅读更多...
NAS外网访问方案

NAS外网访问方案

基础流程 路由器开启端口映射&#xff08;如果有猫则要配置猫为转发模式&#xff0c;由路由器直接拨号即可使用第三方程序让内网ip发布到公网上&#xff08;如果有云服务器&#xff09;需要开启防火墙端口 好用的第三方程序 FRP穿透 优点&#xff1a;开源免费&#xff0c;速…
阅读更多...
C++ 指针进阶

C++ 指针进阶

目录 一、字符指针 二、指针数组 三、数组指针 数组指针的定义 &数组名 与 数组名 数组指针的使用 四、数组参数 一维数组传参 二维数组传参 五、指针参数 一级指针传参 二级指针传参 六、函数指针 七、函数指针数组 八、指向函数指针数组的指针 九、回调函…
阅读更多...
Ubuntu宝塔面板本地部署轻论坛系统HadSky并远程访问

Ubuntu宝塔面板本地部署轻论坛系统HadSky并远程访问

文章目录 前言1. 网站搭建1.1 网页下载和安装1.2 网页测试1.3 cpolar的安装和注册 2. 本地网页发布2.1 Cpolar临时数据隧道2.2 Cpolar稳定隧道&#xff08;云端设置&#xff09;2.3 Cpolar稳定隧道&#xff08;本地设置&#xff09;2.4 公网访问测试 总结 前言 经过多年的基础…
阅读更多...
C++多态（详解）

C++多态（详解）

一、多态的概念 1.1、多态的概念 多态&#xff1a;多种形态&#xff0c;具体点就是去完成某个行为&#xff0c;当不同的对象去完成时会产生出不同的状态。 举个例子&#xff1a;比如买票这个行为&#xff0c;当普通人买票时&#xff0c;是全价买票&#xff1b;学生买票时&am…
阅读更多...
百度推送收录工具-免费的各大搜索引擎推送工具

百度推送收录工具-免费的各大搜索引擎推送工具

在互联网时代&#xff0c;网站收录是网站建设的重要一环。百度推送工具作为一种提高网站收录速度的方式备受关注。在这个信息爆炸的时代&#xff0c;对于网站管理员和站长们来说&#xff0c;了解并使用一些百度推送工具是非常重要的。本文将重点分享百度批量域名推送工具和百度…
阅读更多...
深入理解JVM内存空间的担保策略

深入理解JVM内存空间的担保策略

Java虚拟机&#xff08;JVM&#xff09;的内存管理是Java性能调优中最重要的方面之一&#xff0c;特别是在处理大型应用和服务时。JVM内存管理的一个关键组成部分是垃圾回收&#xff08;GC&#xff09;。在GC过程中&#xff0c;JVM需要确保有足够的内存来创建新对象&#xff0c…
阅读更多...
景联文科技解读《2023人工智能基础数据服务产业发展白皮书》，助力解决数据标注挑战

景联文科技解读《2023人工智能基础数据服务产业发展白皮书》，助力解决数据标注挑战

前段时间&#xff0c;国家工业信息安全发展研究中心发布《2023人工智能基础数据服务产业发展白皮书》&#xff08;以下简称“白皮书”&#xff09;。 《白皮书》指出&#xff0c;2022年&#xff0c;中国人工智能基础数据服务产业的市场规模为45亿元&#xff0c;预计今年将达到5…
阅读更多...
一步解决 java.io.FileNotFoundException: 找不到文件异常

一步解决 java.io.FileNotFoundException: 找不到文件异常

1.问题描述 java.io.FileNotFoundException: C:\Users\Administrator\AppData\Local\Temp\localhost\uploads\image\20231206\2843cb16-9654-4e52-a757-76e3ca1f80ff.png (系统找不到指定的路径。) 2.原因分析 文件路径中的文件目录不存在 3.解决方案 方案一&#xff1a;如果…
阅读更多...
最优化方法复习——线性规划之对偶问题

最优化方法复习——线性规划之对偶问题

一、线性规划对偶问题定义 原问题&#xff1a; 对偶问题&#xff1a; &#xff08;1&#xff09;若一个模型为目标求 “极大”&#xff0c;约束为“小于等于” 的不等式&#xff0c;则它的对偶模型为目标求“极小”&#xff0c;约束是“大于等于”的不等式。即“Max&#xff0…
阅读更多...
docker基本管理和概念

docker基本管理和概念

1、定义&#xff1a;一个开源的应用容器引擎&#xff0c;基于go语言开发&#xff0c;运行在liunx系统中的开源的、轻量级的“虚拟机” docker的容器技术可以在一台主机上轻松的为任何应用创建一个轻量级的、可移植的、自给自足的容器 docker的宿主机是liunx系统&#xff0c;集…
阅读更多...
Maven——使用Nexus创建私服

Maven——使用Nexus创建私服

私服不是Maven的核心概念&#xff0c;它仅仅是一种衍生出来的特殊的Maven仓库。通过建立自己的私服&#xff0c;就可以降低中央仓库负荷、节省外网带宽、加速Maven构建、自己部署构件等&#xff0c;从而高效地使用Maven。 有三种专门的Maven仓库管理软件可以用来帮助大家建立…
阅读更多...
六个自媒体写作方法，提升自媒体创作收益

六个自媒体写作方法，提升自媒体创作收益

在自媒体时代&#xff0c;写作成为了一个不可或缺的技能。特别是对于新手来说&#xff0c;掌握一些有效的写作方法&#xff0c;可以事半功倍&#xff0c;更好地展现个人创意和观点。在这里&#xff0c;我将分享六个适合新手的自媒体写作方法&#xff0c;希望能够为你在写作之路…
阅读更多...
simulinkDFIG风电场风机并网渗透率系统稳定性小信号特征值分析，特征根轨迹分析。四机两区域模型系统

simulinkDFIG风电场风机并网渗透率系统稳定性小信号特征值分析，特征根轨迹分析。四机两区域模型系统

分析了不同风电渗透水平的根轨迹。特征根
阅读更多...
class039 嵌套类问题的递归解题套路【算法】

class039 嵌套类问题的递归解题套路【算法】

class039 嵌套类问题的递归解题套路 算法讲解039【必备】嵌套类问题的递归解题套路 Code1 772. 基本计算器 III 实现一个基本的计算器来计算简单的表达式字符串。 表达式字符串只包含非负整数&#xff0c;算符、-、*、&#xff0c; ,左括号(和右括号)。整数除法需要向下截…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023