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

【容器底层技术】 namespaces详解 namespaces是 Linux 内核的一项功能,它对内核资源进行隔离,让一组进程只能看到与自己相关的一部分资源,而另一组进程看到另一组资源, 使得处于不同 namespaces 的进程拥有独立的全局系统资源,改变一个 namespaces 中的系统资源只会影响当前 namespaces 里的进程,对其他 namespaces 中的进程没有影响。该功能通过为一组资源和进程使用相同的namespace来工作,不同的namespace会引用不同的资源, 有些资源可能存在于多个空间中,比如进程 ID、主机名、用 阅读详情

来自:探索云原生 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  COMMAND
    1 root      0:00 sh
    7 root      0:00 ps
/ # ip a 
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_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:ff
    inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
       valid_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进程所属的namespace
 lixd  ~  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.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	if 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.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	if 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.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	if 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 /proc

root@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 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host
       valid_lft forever preferred_lft forever
2: bond0: <BROADCAST,MULTICAST,MASTER> mtu 1500 qdisc noop state DOWN group default qlen 1000
    link/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 1000
    link/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 1000
    link/ipip 0.0.0.0 brd 0.0.0.0
5: sit0@NONE: <NOARP> mtu 1480 qdisc noop state DOWN group default qlen 1000
    link/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 1000
    link/ether 00:15:5d:6e:f2:65 brd ff:ff:ff:ff:ff:ff
    inet 172.18.167.21/20 brd 172.18.175.255 scope global eth0
       valid_lft forever preferred_lft forever
    inet6 fe80::215:5dff:fe6e:f265/64 scope link
       valid_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 1000
    link/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 1000
    link/ipip 0.0.0.0 brd 0.0.0.0
3: sit0@NONE: <NOARP> mtu 1480 qdisc noop state DOWN group default qlen 1000
    link/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. 参考

Linux的命名空间 命名空间提供了虚拟化的一种轻量级形式,使得我们可以从不同的方面来查看运行系统的全局属性。 一、基本概念 命名空间(Linux namespace)是linux内核针对实现容器虚拟化映入的一个特性。我们创建的每个容器都有自己的命名空间,运行在其中的应用都像是在独立的操作系统中运行一样,命名空间保证了容器之间互不影响。 Linux的命名空间机制提供了一种资源隔离的解决方案。PID,IPC,Network等系统资源不再是全局性的,而是属于特定的Namespace。Namespace是对全局系统资源的一种封装隔离, 阅读详情

相关推荐

Linux Namespace 深度拆解:从容器隔离原理到云原生排障实战

容器技术之所以能成为云原生时代的基石,核心并非硬件虚拟化,而是 Linux 内核提供的进程视角隔离机制。理解这一机制,是掌握 Docker、Kubernetes 底层逻辑和排查容器运行异常的关键前提。内核通过 Namespace 为进程组创建独立的资源视图,涵盖进程号、挂载点、网络协议栈、主机名等维度,使容器内的进程仿佛运行于独立的操作系统之中。本文从内核原理出发,梳理 8 种 Namespace 的隔离对象与适用场景,并通过 unshare 命令手动构建一个不依赖 Docker 的伪容器,直观还原容器创建

weixin_30983353的博客 268

linux namespace的概述

1.namespace是Linux系统的底层概念,在内核层实现,即有一些不同类型的命名空间被部署在核内,各个docker容器运行在同一个docker主进程并且共 用同一个宿主机系统内核,各docker容器运行在宿主机的用户空间,每个容器都要有类似于虚拟机一样的相互隔离的运行空间,但是容器技术是在一个 进程内实现运行指定服务的运行环境,并且还可以保护宿主机内核不受其他进程的干扰和影响,如文件系统空间、网络空间、进程空间等,目前主要通过 以下8种技术实现容器运行空间的相互隔离.

dizhegccl的博客 2369

Docker源码分析(七):Docker Container网络 (上)

1.前言(什么是Docker Container)如今,Docker技术大行其道,大家在尝试以及玩转Docker的同时,肯定离不开一个概念,那就是“容器”或者“Docker Container”。那么我们首先从实现的角度来看看“容器”或者“Docker Container”到底为何物。逐渐熟悉Docker之后,大家肯定会深深得感受到:应用程序在Docker Container内部的部署与运行非常便捷

木精灵的技术博客 1462

命名空间——时间 (time)

Linux内核5.6引入的Time命名空间实现了进程组时间隔离,允许不同命名空间拥有独立的墙上时间和单调时间视图。通过sudo unshare -T命令可创建新的Time命名空间,在其中修改时间不会影响其他命名空间。/proc/[PID]/ns/目录中的time和time_for_children文件分别控制当前进程和子进程的时间视图,实现更精细的时间隔离管理。该特性为容器等隔离环境提供了独立的时间流支持。

woshihlf的博客 586

Docker环境隔离原理与机器学习可复现实践

Docker是一种基于Linux内核Namespaces和Cgroups的轻量级容器技术,通过进程隔离、资源限制与分层镜像机制,实现运行环境的强一致性与可复现性。其核心价值在于解决‘环境漂移’问题——当开发、测试与生产环境因系统版本、依赖库或CUDA配置差异导致ModuleNotFoundError等故障时,Docker以‘一次构建、处处运行’保障逻辑错误可归因、不可归咎于基础设施。在机器学习场景中,结合精确版本锁定的requirements.txt与多阶段构建,既能复现PyTorch训练结果,又能显著压缩

225

Docker 核心原理详解:Namespaces 与 Cgroups 如何实现资源隔离与限制

Docker 作为容器化技术的代表,通过 Linux 内核的 Namespaces 和 Cgroups 技术,实现了轻量、快速且一致的运行环境。Namespaces 负责隔离系统资源,如进程、网络、文件系统等,使得每个容器拥有独立的资源视图;Cgroups 则负责限制和监控容器的资源使用,如 CPU、内存等,确保资源分配的公平性和安全性。相比于传统的虚拟机技术,Docker 容器共享宿主机内核,避免了额外操作系统的开销,启动更快,资源利用率更高。

专栏 803

深入探索Docker的隔离艺术:Namespace机制如何实现容器间的“独立王国”

在Docker的世界里,每个容器仿佛是一个微缩版的操作系统环境,它们各自运行、互不干扰。这一神奇现象背后的功臣正是Linux内核的Namespace技术。本文将揭开Namespace的基本原理和特性,探讨Docker是如何借助Namespace实现资源隔离,构建起一个个独立且高效的容器世界。

guting18893110463的博客 903

专项1.CCS代码补全与快捷键优化全攻略

本文全面解析CCS开发环境的代码补全功能与快捷键优化技巧,包括内容辅助触发机制、快捷键自定义配置、编码效率提升方法等实用内容。通过详细步骤指导开发者优化CCS配置,实现高效的代码自动补全和个性化快捷键设置,显著提升嵌入式开发效率。

kotlin6android的博客 226

linux namespace 隔离内核资源的方式 简介

namespace 的概念 namespace 是 Linux 内核用来隔离内核资源的方式。通过 namespace 可以让一些进程只能看到与自己相关的一部分资源,而另外一些进程也只能看到与它们自己相关的资源,这两拨进程根本就感觉不到对方的存在。具体的实现方式是把一个或多个进程的相关资源指定在同一个 namespace 中。 Linux namespaces 是对全局系统资源的一种封装隔离,使...

whatday的专栏 2385

告别瞎猜!用通达信L2资金流向函数,手把手教你识别主力动向(附实战公式)

本文详细解析通达信L2资金流向函数,手把手教你构建主力动向监控系统。通过分档数据解析、委买委卖攻防解读及实战公式应用,帮助投资者精准识别主力建仓与虚假拉升信号,提升股票交易决策效率。

weixin_26908317的博客 2111

学习海康VisionMaster之路径提取

这里也需要注意下,这里有两种模式,在运行参数的这一栏有“等距离取点”和“查找边缘点”两个检测模式,说实话,那个等距离取点我也没搞懂有什么用,我拿了OK和NG的图片去对比,好像没有什么实际用处,无法检测(不知道有没有小伙伴知道这个模式到底是怎么用的!2:应用场景:典型的场景是点胶检测,判断胶路质量,有没有断胶等,一开始这胶路检测,真的是难倒我了,特别是不规则图像如何检测,学习了这个算子后,思路一下子打开了,原来还可以这么搞!四:实测:上述设定好参数,开始实际测量看看效果,不同的检测模式下的检测效果。

yuhouxiyang的专栏 1488

Linux Namespace : 简介

namespace 的概念 namespace 是 Linux 内核用来隔离内核资源的方式。通过 namespace 可以让一些进程只能看到与自己相关的一部分资源,而另外一些进程也只能看到与它们自己相关的资源,这两拨进程根本就感觉不到对方的存在。具体的实现方式是把一个或多个进程的相关资源指定在同一个 namespace 中。 Linux namespaces 是对全局系统资源的一种封装隔离,使得处于不同 namespace 的进程拥有独立的全局系统资源,改变一个 namespace 中的系统资源只会影响

一口Linux的专栏 1002

跨境TRS投资操作指南与系统解决方案

3 点击【申请 TRS 账户】,查看风险披露,录入账户参数、确定录入的参数信息,进行身份验证,输入验证码,TRS 账户开户申请已提交,后台对已提交的 TRS 开户申请进行审核,审核成功后,短信邮箱提醒,进行登录;2.点击【申请TRS账户】,查看风险披露,录入账户参数、确定录入的参数信息,进行身份验证,输入验证码,TRS账户开户申请已提交,后台对已提交的TRS开户申请进行审核,审核成功后,短信邮箱提醒,进行登录;4)更广泛的投资选择:相比A股通,TRS可以交易更多的A股标的,提供了更广泛的投资选择。

2401_85487119的博客 2854

Docker如何实现隔离的

Docker是如何实现隔离的

RenLJ1895的博客 2108

学Simulink——四开关 Buck‑Boost(FSBB)变换器的无缝模式切换仿真

本文详细介绍了使用Simulink实现四开关Buck-Boost(FSBB)变换器无缝模式切换的仿真方法。FSBB变换器因其输入输出同极性、单电感和双向能量流特性,广泛应用于光伏储能、USB-PD和车载电源等场景。文章重点解决了模式切换中的直通风险和占空比跳变问题,通过统一电压PI控制、Stateflow模式仲裁和200ns死区设计,实现了Buck(26V→24V)、Pass-Through(24V±1V)和Boost(22V)三种工作模式的无缝过渡。仿真结果显示输出电压稳定在12V±0.15V,切换过程无

amy_mhd的博客 68

手把手教你学Simulink——四开关 Buck‑Boost(FSBB)变换器的无缝模式切换仿真

本文详细介绍了四开关Buck-Boost(FSBB)变换器的Simulink仿真方法,重点解决模式切换时的直通风险和输出电压波动问题。通过统一电压PI控制、迟滞比较模式仲裁(Buck/Boost/Pass-Through)和200ns死区设计,实现了Vin从26V到22V变化时Vout稳定在12V±0.15V。关键步骤包括:搭建功率级电路、Stateflow模式判断、PI控制器输出占空比映射(Buck模式D≈Vo/Vin,Boost模式D≈1-Vo/Vin),以及带死区的PWM信号分配。仿真验证了切换过程中

MHD0815的博客 118

Linux 命名空间(Namespace)实战指南:从原理到容器化应用

本文深入解析Linux命名空间(Namespace)的核心原理与七种隔离类型,并通过实战演示如何手动创建隔离环境及组合命名空间来构建一个“迷你容器”。文章揭示了Docker等容器技术实现隔离性的底层机制,帮助开发者从本质上理解容器化,并掌握利用命名空间进行高级运维和问题诊断的技能。

bread的博客 1037

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

白话容器namespace

脚本后续更新及迭代将由kkitDeploy项目代替 https://github.com/luckman666/kkitdeploy_server 请大家持续关注kkitDeploy 进入正题之前是例行装X环节: 过年7天吃的,花了45天又回来了。 近年来容器大火,也正是因为容器,生生灭掉了一个IT岗位!哥也是被生生的逼上了邪路。 那究竟什么是容器...

anqunluo5527的博客 210

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

容器学习笔记(二)Namespace

Namespace 这一节,我给大家介绍docker的namespace是如何实现资源隔离的 Namespace其实是linux很早就有的一个功能吧,但是因为docker它才被更多的人所熟悉。Linux提供了其中不同的命名空间,分别用于隔离不同的资源 通过这几个命名空间的选项,我们可以在创建新的进程时设置它和宿主机器的其他进程进行哪些资源的隔离。 进程隔离 大家都知道linux的进程是一个树形结构树根是pid为0的上帝进程。还有两个非常特殊的命令一个是pid为1的 /sbin/init进程和pid为2的k

tyro_blog的博客 595

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

笔记 | 用go写个docker

仅作为自己学习过程的记录,不具备参考价值!

Trollz的博客 1553

docker简介

摘要: Docker作为轻量级容器技术,解决了软件开发中环境不一致的痛点。相比传统虚拟化,Docker通过进程级隔离实现秒级启动、低性能损耗和环境一致性。本系列将从核心概念(镜像/容器/仓库)、安装配置、常用命令到Dockerfile编写、数据卷管理和Docker-Compose编排展开实战教学,帮助开发者实现"一次构建,处处运行"。通过打包代码与依赖环境,Docker彻底避免了开发、测试、生产环境差异导致的问题,成为云原生时代必备技能。

casually的博客 862

七天用Go写个docker(第一天)

1. docker详解 很多人刚接触docker的时候就会感觉非常神奇,感觉这个技术非常新颖,其实并不然,docker使用到的技术都是之前已经存在过的,只不过旧酒换了新瓶罢了。简单来说docker本质其实是一个特殊的进程,这个进程特殊在它被Namespace和Cgroup 技术做了装饰,Namespace将该进程与Linux系统进行隔离开来,让该进程处于一个虚拟的沙盒中,而Cgroup则对该进程...

跟派大星学编程 1672
上一篇: 深入理解 Docker 核心原理:Namespace、Cgroups 和 Rootfs
下一篇: 初探 Linux Cgroups:资源控制的奇妙世界
探索云原生
博客等级 码龄9年 730粉丝 131原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值