深入理解 Docker 核心原理:Namespace、Cgroups 和 Rootfs

从零实现简易Docker引擎:深入解析Namespace、Cgroups与OverlayFS原理 容器技术是现代云计算和微服务架构的核心基石,其本质是通过操作系统内核提供的隔离与资源管理机制,为应用提供轻量级、可移植的运行环境。其核心原理主要基于Linux内核的Namespace、Cgroups和联合文件系统三大特性。Namespace实现了进程、网络、文件系统等资源的视图隔离,让每个容器拥有独立的系统资源视角;Cgroups则负责对进程组使用的CPU、内存等物理资源进行精确的限制、分配和统计,是资源管控的关键。这些技术的结合,为应用的快速部署、环境一致性以及高效的资源利用率提供了底层支持,广泛应用于持 阅读详情

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

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

通过这篇文章你可以了解到 Docker 容器的核心实现原理,包括 Namespace、Cgroups、Rootfs 等三个核心功能。

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

更新记录

第一版:写于 2021-02-14

第二版:更新于 2023.10.22,迁移到公众号,重制了一下

docker-core

首先我们思考一个问题:容器与进程有何不同?

  • 进程:就是程序运行起来后的计算机执行环境的总和。

即:计算机内存中的数据、寄存器里的值、堆栈中的指令、被打开的文件,以及各种设备的状态信息的一个集合。

  • 容器:核心就是通过约束和修改进程的动态表现,从而为其创造出一个“边界”。

对于 Docker 等大多数 Linux 容器来说,Cgroups 技术是用来制造约束的主要手段,而 Namespace 技术则是用来修改进程视图的主要方法。

1. 基于 Namespace 的视图隔离

当我们通过 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 :

  • 1)PID Namespace
  • 2)Mount Namespace
  • 3)UTS Namespace
  • 4)IPC Namespace
  • 5)Network Namespace
  • 6)User Namespace

通过不同类型的 Namespace 就可以实现不同资源的隔离,比如前面通过 ip a 只能看到容器中的网卡信息,就是通过 Network Namespace进行了隔离。

不过 Linux Namespace 技术实际上修改了应用进程看待整个计算机“视图”,即它的“视线”被操作系统做了限制,只能“看到”某些指定的内容。

我们只需要进入到对应 namespace 就可以突破这个隔离了,演示一下:

首先启动一个 busybox,然后使用 ip a 查看网卡信息

[root@docker ~]# docker run --rm -it busybox /bin/sh
/ # 
/ # ip a show eth0
116: eth0@if117: <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

容器中 ip 为 172.17.0.2

然后在新终端中通过 nsenter 进入到该容器 network namespace 试试:

首先通过 docker inspect 命令找到容器对应的 PID

[root@docker ~]# docker ps
CONTAINER ID   IMAGE     COMMAND     CREATED          STATUS          PORTS     NAMES
75e821d24261   busybox   "/bin/sh"   32 seconds ago   Up 31 seconds             great_heisenberg
[root@docker ~]# docker inspect -f '{{.State.Pid}}' 75e821d24261
3533

然后使用 nsenter --net 命令进入该 PID 对应进程的 network namespace

[root@docker ~]# nsenter --target 3533 --net
[root@docker ~]# ip a show eth0
116: eth0@if117: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever

可以看到,此时我们执行 ip a 拿到的信息和在容器中执行是完全一致的。

说明 Docker 确实是使用 namespace 进行隔离的。

这里顺便提一下 Namespace 存在的问题,Namespace 最大的问题就是隔离得不彻底。

  • 首先,既然容器只是运行在宿主机上的一种特殊的进程,那么多个容器之间使用的就还是同一个宿主机的操作系统内核。

所以,也出现了像 Firecracker、gVisor、Kata 之类的沙箱容器,不使用共享内核来提升安全性。

  • 其次,在 Linux 内核中,有很多资源和对象是不能被 Namespace 化的,最典型的例子就是:时间。

容器中修改了时间,实际修改的是宿主机的时间,会导致所有容器时间都被修改,因为是共享的。

2. 基于 Cgroups 的资源限制

docker run 启动容器时可以通过增加 --cpus 或者 --memory flag 来指定 cpu、内存限制。

就像这样:通过 --cpus=0.5 限制只能使用 0.5 个核心,然后执行一个 while 死循环,并查看 cpu 占用情况。

[root@docker ~]# docker run  -d --cpus 0.5  busybox sh -c "while true; do :; done"
d281fb2dc96cff371e9607197502c6ea3e04f4d0f3fd2ad38991c2321271736b

查看 CPU 占用情况

[root@docker ~]# top
top - 15:38:20 up 286 days,  4:02,  3 users,  load average: 0.72, 0.46, 0.36
Tasks:  96 total,   2 running,  48 sleeping,   0 stopped,   0 zombie
%Cpu(s): 52.0 us,  0.0 sy,  0.0 ni, 47.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.3 st
KiB Mem :  1006956 total,   157876 free,   201008 used,   648072 buff/cache
KiB Swap:        0 total,        0 free,        0 used.   538972 avail Mem 

  PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND                                                                                                                                                                                       
 3763 root      20   0    4392    400    336 R 50.0  0.0   0:49.43 sh                                                                                                                                                                                            
 3790 root      20   0  162112   4416   3724 R  0.3  0.4   0:00.01 top                                                                                                                                                                                           
    1 root      20   0   43884   4280   2552 S  0.0  0.4   1:56.18 systemd

可以看到,因为限制了 cpu 为 0.5,因此只占用了 0.5 核心,也就是 top 命令中看到的 50。

这就是 Docker 另一个核心功能,基于 Linux Cgroups 技术实现的资源限制。

Linux Cgroups 就是 Linux 内核中用来为进程设置资源限制的一个重要功能。

Linux Cgroups 的全称是 Linux Control Group。

它最主要的作用,就是限制一个进程组能够使用的资源上限,包括 CPU、内存、磁盘、网络带宽等等。

在 Linux 中,Cgroups 给用户暴露出来的操作接口是文件系统,即它以文件和目录的方式组织在操作系统的 /sys/fs/cgroup 路径下,可以使用

mount -t cgroup 命令进行查看,大概长这样:

[root@docker ~]# mount -t cgroup
cgroup on /sys/fs/cgroup/systemd type cgroup (rw,nosuid,nodev,noexec,relatime,xattr,release_agent=/usr/lib/systemd/systemd-cgroups-agent,name=systemd)
cgroup on /sys/fs/cgroup/net_cls,net_prio type cgroup (rw,nosuid,nodev,noexec,relatime,net_cls,net_prio)
cgroup on /sys/fs/cgroup/devices type cgroup (rw,nosuid,nodev,noexec,relatime,devices)
cgroup on /sys/fs/cgroup/perf_event type cgroup (rw,nosuid,nodev,noexec,relatime,perf_event)
cgroup on /sys/fs/cgroup/blkio type cgroup (rw,nosuid,nodev,noexec,relatime,blkio)
cgroup on /sys/fs/cgroup/memory type cgroup (rw,nosuid,nodev,noexec,relatime,memory)
cgroup on /sys/fs/cgroup/hugetlb type cgroup (rw,nosuid,nodev,noexec,relatime,hugetlb)
cgroup on /sys/fs/cgroup/rdma type cgroup (rw,nosuid,nodev,noexec,relatime,rdma)
cgroup on /sys/fs/cgroup/cpu,cpuacct type cgroup (rw,nosuid,nodev,noexec,relatime,cpu,cpuacct)
cgroup on /sys/fs/cgroup/freezer type cgroup (rw,nosuid,nodev,noexec,relatime,freezer)
cgroup on /sys/fs/cgroup/cpuset type cgroup (rw,nosuid,nodev,noexec,relatime,cpuset)
cgroup on /sys/fs/cgroup/pids type cgroup (rw,nosuid,nodev,noexec,relatime,pids)

可以看到,在/sys/fs/cgroup 下面有很多诸如 cpuset、cpu、 memory 这样的子目录,也叫子系统。

即:这台机器当前可以被 Cgroups 进行限制的资源种类。

比如,对 CPU 子系统来说,我们就可以看到如下几个配置文件:

[root@docker ~]# ls /sys/fs/cgroup/cpu
cgroup.clone_children  cgroup.sane_behavior  cpuacct.stat   cpuacct.usage_all     cpuacct.usage_percpu_sys   cpuacct.usage_sys   cpu.cfs_period_us  cpu.rt_period_us   cpu.shares  docker             release_agent  tasks
cgroup.procs            cpuacct.usage  cpuacct.usage_percpu  cpuacct.usage_percpu_user  cpuacct.usage_user  cpu.cfs_quota_us   cpu.rt_runtime_us  cpu.stat    notify_on_release  system.slice   user.slice

这些配置文件定义了如何对 CPU 进行限制,以及需要对哪些进程进行限制。

那么配置文件又如何使用呢?下面我们来演示一下具体使用。

例子:限制 CPU 使用

你需要在对应的子系统下面创建一个目录,比如,我们现在进入 /sys/fs/cgroup/cpu 目录下创建一个名为 container 的目录:

[root@docker ~]# cd /sys/fs/cgroup/cpu
[root@docker cpu]# mkdir container

这个目录就是一个“控制组”。

你会发现,操作系统会在你新创建的 container 目录下,自动生成该子系统对应的资源限制文件。

[root@docker cpu]# ls container
cgroup.clone_children  cpuacct.stat   cpuacct.usage_all     cpuacct.usage_percpu_sys   cpuacct.usage_sys   cpu.cfs_period_us  cpu.rt_period_us   cpu.shares  notify_on_release
cgroup.procs           cpuacct.usage  cpuacct.usage_percpu  cpuacct.usage_percpu_user  cpuacct.usage_user  cpu.cfs_quota_us   cpu.rt_runtime_us  cpu.stat    tasks

接下来我们就通过修改配置文件对 CPU 进行限制,这里就用前面创建的 container 这个“控制组”。

主要通过以下三个文件来实现

  • cpu.cfs_quota_us:每个控制周期内,进程可以使用的 cpu 时间,默认为 -1,即不做限制。
  • cpu.cfs_period_us:控制周期,默认为 100 ms
  • tasks:记录被限制进程的 PID 列表

cgroups 会限制所有在 tasks 中的进程,在 cpu.cfs_period_us 周期内,最多只能使用 cpu.cfs_quota_us 的 cpu 资源。

比如,100ms 能限制只能使用 20ms,即最多占用 0.2 核心

首先,我们在后台执行这样一条脚本:

[root@docker cpu]# while : ; do : ; done &
[1] 3892

显然,它执行了一个死循环,可以把计算机的 CPU 吃到 100%。根据它的输出,我们可以看到这个脚本在后台运行的进程号(PID)是 3892。

执行 Top 查看一下 CPU 占用,可以看到这个 3892 进程占用了差不多 100% 的 CPU,把一个核心占满了。

[root@docker cpu]# top
top - 16:07:06 up 286 days,  4:31,  3 users,  load average: 0.59, 0.50, 0.50
Tasks:  97 total,   2 running,  48 sleeping,   0 stopped,   0 zombie
%Cpu(s):100.0 us,  0.0 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem :  1006956 total,   166520 free,   190840 used,   649596 buff/cache
KiB Swap:        0 total,        0 free,        0 used.   549216 avail Mem 

  PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND                                                                                                                                                                                       
 3892 root      20   0  115684    532      0 R 92.0  0.1   0:48.64 bash

此时,我们就可以通过配置 cgroups 来实现对该进程的 CPU 使用情况进行限制。

默认情况下 container 控制组里的 CPU quota 还没有任何限制(即:-1),CPU period 则是默认的 100 ms(100000 us),因此上述进程可以占用整个 CPU。

[root@docker cpu]# cat /sys/fs/cgroup/cpu/container/cpu.cfs_quota_us 
-1
[root@docker cpu]# cat /sys/fs/cgroup/cpu/container/cpu.cfs_period_us 
100000

接下来,我们可以通过修改这配置文件来设置 CPU 限制。比如,向 container 组里的 cfs_quota 文件写入 20 ms(20000 us)来做限制。

[root@docker cpu]# echo 20000 > /sys/fs/cgroup/cpu/container/cpu.cfs_quota_us
[root@docker cpu]# cat /sys/fs/cgroup/cpu/container/cpu.cfs_quota_us
20000

最后则是将进程 PID 写入 tasks 文件里,是配置生效。

[root@docker cpu]# echo 3892 > /sys/fs/cgroup/cpu/container/tasks 
[root@docker cpu]# cat /sys/fs/cgroup/cpu/container/tasks
3892

然后查看是否生效:

[root@docker cpu]# top
top - 16:13:56 up 286 days,  4:38,  3 users,  load average: 0.20, 0.61, 0.59
Tasks:  94 total,   2 running,  48 sleeping,   0 stopped,   0 zombie
%Cpu(s): 21.6 us,  0.0 sy,  0.0 ni, 78.1 id,  0.0 wa,  0.0 hi,  0.0 si,  0.3 st
KiB Mem :  1006956 total,   166552 free,   190808 used,   649596 buff/cache
KiB Swap:        0 total,        0 free,        0 used.   549248 avail Mem 

  PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND                                                                                                                                                                                       
 3892 root      20   0  115684    532      0 R 19.9  0.1   5:56.94 bash

可以看到,果然 3892 CPU 被限制到了 20%。

除 CPU 子系统外,Cgroups 的每一个子系统都有其独有的资源限制能力,比如:

  • blkio,为块设备设定I/O 限制,一般用于磁盘等设备;
  • cpuset,为进程分配单独的 CPU 核和对应的内存节点;
  • memory,为进程设定内存使用的限制。

Linux Cgroups 的设计还是比较易用的,简单粗暴地理解呢,它就是一个子系统目录加上一组资源限制文件的组合。

而对于 Docker 等 Linux 容器项目来说,它们只需要在每个子系统下面,为每个容器创建一个控制组(即创建一个新目录),然后在启动容器进程之后,把这个进程的 PID 填写到对应控制组的 tasks 文件中就可以了。

而至于在这些控制组下面的资源文件里填上什么值,就靠用户执行 docker run 时的参数指定了,比如这样一条命令:

docker run -it --cpu-period=100000 --cpu-quota=20000 ubuntu /bin/bash

在启动这个容器后,我们可以通过查看 Cgroups 文件系统下,CPU 子系统中,“docker”这个控制组里的资源限制文件的内容来确认:

$ cat /sys/fs/cgroup/cpu/docker/5d5c9f67d/cpu.cfs_period_us
100000
$ cat /sys/fs/cgroup/cpu/docker/5d5c9f67d/cpu.cfs_quota_us
20000

3. 容器镜像的秘密

这部分主要解释以下三个问题

  • 1)为什么在容器中修改了文件宿主机不受影响?
  • 2)容器中的文件系统是哪儿来的?
  • 3)docker 镜像又是怎么实现的?

这也是 Docker 的第三个核心功能:容器镜像(rootfs),将运行环境打包成镜像,从而避免环境问题导致应用无法运行。

1. 文件系统

容器中的文件系统是什么样子的?

因为容器中的文件系统经过 Mount Namespace 隔离,所以应该是独立的。

其中 Mount Namespace 修改的,是容器进程对文件系统“挂载点”的认知。只有在“挂载”这个操作发生之后,进程的视图才会被改变。而在此之前,新创建的容器会直接继承宿主机的各个挂载点。

不难想到,我们可以在容器进程启动之前重新挂载它的整个根目录“/”。而由于 Mount Namespace 的存在,这个挂载对宿主机不可见,所以容器进程就可以在里面随便折腾了。

Linux 中 chroot 命令(change root file system)就能很方便的完成上述工作。

而 Mount Namespace 正是基于对 chroot 的不断改良才被发明出来的,它也是 Linux 操作系统里的第一个 Namespace。

至此,第一个问题 为什么在容器中修改了文件宿主机不受影响?有答案了,因为使用 Mount Namespace 隔离了。

2. rootfs

上文提到 Mount Namespace 会修改容器进程对文件系统挂载点的认知,而这个挂载在容器根目录上、用来为容器进程提供隔离后执行环境的文件系统,就是所谓的“容器镜像”。它还有一个更为专业的名字,叫作:rootfs(根文件系统)。

rootfs 只是一个操作系统所包含的文件、配置和目录,并不包括操作系统内核。在 Linux 操作系统中,这两部分是分开存放的,操作系统只有在开机启动时才会加载指定版本的内核镜像。

所以说,rootfs 只包括了操作系统的“躯壳”,并没有包括操作系统的“灵魂”。实际上,同一台机器上的所有容器,都共享宿主机操作系统的内核。

这也是容器相比于虚拟机的主要缺陷之一:毕竟后者不仅有模拟出来的硬件机器充当沙盒,而且每个沙盒里还运行着一个完整的 Guest OS 给应用随便折腾。

不过,正是由于 rootfs 的存在,容器才有了一个被反复宣传至今的重要特性:一致性。由于 rootfs 里打包的不只是应用,而是整个操作系统的文件和目录,也就意味着,应用以及它运行所需要的所有依赖,都被封装在了一起。

第二个问题:容器中的文件系统是哪儿来的?实际上是我们构建镜像的时候打包进去的,然后容器启动时挂载到了根目录下。

3. 镜像层(Layer)

Docker 在镜像的设计中,引入了层(layer)的概念。也就是说,用户制作镜像的每一步操作,都会生成一个层,也就是一个增量 rootfs。

通过引入层(layer)的概念,实现了 rootfs 的复用。不必每次都重新创建一个 rootfs,而是基于某一层进行修改即可。

Docker 镜像层用到了一种叫做**联合文件系统(Union File System)**的能力。Union File System 也叫 UnionFS,最主要的功能是将多个不同位置的目录联合挂载(union mount)到同一个目录下。

例如将目录 A 和目录 B 挂载到目录 C 下面,这样目录 C 下就包含目录 A 和目录 B 的所有文件。

由于看不到目录 A 和 目标 B 的存在,因此就好像 C 目录就包含这么多文件一样

Docker 镜像分为多个层,然后使用 UFS 将这多个层挂载到一个目录下面,这样这个目录就包含了完整的文件了。

UnionFS 在不同系统有各自的实现,所以 Docker 的不同发行版使用的也不一样,可以通过 docker info 查看。常见有 aufs(ubuntu 常用)、overlay2(centos 常用)

就像下图这样:union mount 在最上层,提供了统一的视图,用户看起来好像整个系统只有一层一样,实际上下面包含了很多层。

镜像只包含了静态文件,但是容器会产生实时数据,所以容器的 rootfs 在镜像的基础上增加了可读写层和 Init 层。

即容器 rootfs 包括:只读层(镜像rootfs)+ init 层(容器启动时初始化修改的部分数据) + 可读写层(容器中产生的实时数据)。

只读层(镜像rootfs)

它是这个容器的 rootfs 最下面的几层,即镜像中的所有层的总和,它们的挂载方式都是只读的(ro+wh,即 readonly+whiteout)

可读写层(容器中产生的实时数据)

它是这个容器的 rootfs 最上面的一层,它的挂载方式为:rw,即 read write。在没有写入文件之前,这个目录是空的。

而一旦在容器里做了写操作,你修改产生的内容就会以增量的方式出现在这个层中,删除操作实现比较特殊(类似于标记删除)。

AUFS 的 whiteout 的实现是通过在上层的可写的目录下建立对应的 whiteout 隐藏文件来实现的。

为了实现删除操作,aufs(UnionFS 的一种实现) 会在可读写层创建一个 whiteout 文件,把只读层里的文件“遮挡”起来。

比如,你要删除只读层里一个名叫 foo 的文件,那么这个删除操作实际上是在可读写层创建了一个名叫.wh.foo 的文件。这样,当这两个层被联合挂载之后,foo 文件就会被.wh.foo 文件“遮挡”起来,“消失”了。

init 层(容器启动时初始化修改的部分数据)

它是一个以“-init”结尾的层,夹在只读层和读写层之间,Init 层是 Docker 项目单独生成的一个内部层,专门用来存放 /etc/hosts、/etc/resolv.conf 等信息。

为什么需要 init 层?

比如 hostname 这样的数据,原本是属于镜像层的一部分,要修改的话只能在可读写层进行修改,但是又不想在 docker commit 的时候把这些信息提交上去,所以使用 init 层来保存这些修改。

可以理解为提交代码的时候一般也不会把各种配置信息一起提交上去。

docker commit 只会提交 只读层和可读写层。

最后一个问题:docker 镜像又是怎么实现的?通过引入 layer 概念进行分层,借助 联合文件系统(Union File System)进行叠加,最终构成了完整的镜像。

这里只是镜像的主要内容,具体怎么把这些内容打包成 image 格式就是 OCI 规范了

4. 小结

至此,我们大致清楚了 Docker 容器的实现主要使用了如下 3 个功能:

  • 1)Linux Namespace 的隔离能力
  • 2)Linux Cgroups 的限制能力
  • 3)基于 rootfs 的文件系统

5. 参考

https://draveness.me/docker/

https://en.wikipedia.org/wiki/Linux_namespaces

https://0xax.gitbooks.io/linux-insides/content/Cgroups/linux-cgroups-1.html

https://coolshell.cn/articles/17061.html

深入剖析Kubernetes

Ubuntu 13.04 + LXC:深入理解Linux容器底层原理的实验沙盒 Linux容器本质是内核提供的进程隔离机制,其核心依赖namespaces(如pid、net、mnt)与cgroups资源控制。理解这些原语,是掌握Docker、Kubernetes等上层平台的基础前提。LXC作为直接暴露内核接口的轻量级容器运行时,不封装、不抽象,让开发者能直观观察clone()系统调用、veth pair绑定、pivot_root切换等关键行为。尤其在Ubuntu 13.04这一历史版本中,user namespaces尚处显式启用阶段,cgroup v1配置透明,网络栈直通bridge 阅读详情

相关推荐

Docker容器化生态全解析:从runc运行时到Registry分发

容器化是一种以操作系统内核为基石、通过进程隔离实现轻量级虚拟化的交付范式。其核心原理依赖cgroups与namespaces等Linux内核特性,由runc/crun等OCI运行时直接调用系统调用完成容器创建,再经Docker Daemon统一调度,最终通过Dockerfile声明构建过程、Registry实现内容寻址分发。这种架构带来毫秒级启动、低资源开销和环境强一致性等技术价值,广泛应用于微服务部署、CI/CD流水线和边缘设备交付等场景。本文聚焦Docker生态四层结构——Runtime、Daemon、

weixin_34025151的博客 716

一文彻底搞懂Docker中的namespace

什么是namespace namespace是对全局系统资源的一种封装隔离。这样可以让不同namespace的进程拥有独立的全局系统资源。这样改变一个namespace的系统资源只会影响当前namespace中的进程,对其它namespace中的资源没有影响。以前Linux也有一个。之前有一个系统调用chroot和namespace类似。 namespcae分类 chroot内部不能访问外部的内容,namespce在此基础上提供了UTS、IPC、mount、PID、network、User等隔离机制。

神技圈子的博客 9212

LXC容器安全与网络配置实战:从Capabilities到Cgroups全解析

在Linux容器技术中,安全隔离与资源控制是保障系统稳定运行的核心基础。其原理在于通过内核提供的命名空间(Namespaces)实现进程、网络等资源的隔离,并结合控制组(Cgroups)机制对CPU、内存等资源进行精细化限制。这项技术的核心价值在于,它使得应用程序能够在轻量级、可预测的沙箱环境中运行,极大地提升了部署密度与运维效率。典型的应用场景包括微服务架构部署、持续集成/持续部署(CI/CD)流水线以及多租户的云原生环境。本文聚焦于LXC(Linux Containers)这一经典实现,深入探讨如何通过

weixin_30292745的博客 469

Docker基础-namespace

Linux namespaces 是对全局系统资源的一种封装隔离,使得处于不同 namespace 的进程拥有独立的全局系统资源,改变一个 namespace 中的系统资源只会影响当前namespace 里的进程,对其他 namespace 中的进程没有影响。出错是因为如果不建新进程,新的 namespace 会用执行 unshare 命令的进程 的 PID 作为新的空间的父进程,而这个 unshare 进程并不在新的 namespace 中,所以会报个错 Cannot allocate memory。

可乐不解渴 808

深入解析UVM寄存器模型:reg2bus与bus2reg的隐式调用机制

本文深入解析了UVM寄存器模型中reg2bus与bus2reg函数的隐式调用机制。通过追踪一次寄存器访问的完整旅程,揭示了这两个关键函数是如何在uvm_reg_map和uvm_reg_predictor中被框架自动调用的,从而在抽象的寄存器操作与具体总线事务之间完成转换,并实现镜像值的自动更新。掌握此机制是高效调试和灵活应用UVM寄存器模型的基础。

weixin_29211309的博客 441

Ansys Zemax实战:5步搞定多模光纤耦合效率优化(附IMAE操作数详解)

本文详细介绍了使用Ansys Zemax优化多模光纤耦合效率的5个关键步骤,包括几何图像分析设置、IMAE操作数应用及偏振效应处理。通过实战案例解析,帮助工程师快速掌握光纤耦合效率提升技巧,特别针对IMAE操作数的配置保存机制和菲涅尔损耗控制进行深度讲解。

potato的博客 693

docker背景知识1 命名空间Namespace(nsenter、lsns命令)

如下操作都是在centos7上执行,通过cat /proc/version查看系统信息。 Linux namespace linux namespaces是Linux提供的一种内核级别环境隔离的方法,也是Container环境隔离的底层技术,Linux Namespaces共有如下种类 分类 系统调用参数 相关内核版本 ...

m0_45406092的博客 3512

数字IC后端设计实现OCC(On-chip Clock Controller)电路介绍及时钟树综合案例

数字IC后端设计实现OCC(On-chip Clock Controller)电路介绍及时钟树综合案例

weixin_37584728的博客 4740

容器三大基石 Cgroups、Namespace、Rootfs

Docker包括三个基本概念镜像:就相当于是一个 root 文件系统。比如官方镜像ubuntu:16.04容器:镜像(Image)和容器(Container)的关系,就像是面向对象程序设计中的类和实例一样,镜像是静态的定义,容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等。仓库:仓库可看成一个代码控制中心,用来保存镜像。

烟雨 589

4090显卡实测:PointPillars在KITTI数据集上的3D目标检测复现全流程(附避坑指南)

本文详细记录了在NVIDIA RTX 4090显卡上,从环境搭建、数据处理到模型训练与评估,完整复现PointPillars算法在KITTI数据集上进行3D目标检测的全流程。重点分享了版本配置、数据预处理、性能调优及常见问题的避坑指南,帮助开发者高效利用硬件资源,成功跑通并理解这一经典3D检测项目。

purple的博客 916

具身智能端到端大模型VLA (Vision Language Action)

在语言为条件的机器人任务中,策略必须具备理解语言指令、视觉感知环境并生成适当动作的能力,这就需要VLA的。例如,在自动驾驶领域,传统的做法是将感知、预测、规划等步骤分开处理,而VLA则试图用一个统一的框架来替代这种分立的方法。另外,VLA的模型对于算力的需求很大,单片AI算力1000Tops的Thor大概率会延期发布,加上英伟达芯片的量产时间与成本挑战,以及在国内的应用情况,对车企而言是个大问题。以谷歌DeepMind推出的RT-2为例,该模型可以在新的物体、背景和环境中表现出显著改善的性能。

具身智能机器人 1万+

Docker学习四:资源隔离——Namespace

Docker学习系列

weixin_41402069的博客 2590

Maxwell个人初学经验及资料分享

前段时间学习了课题组基于Maxwell所建立的模型,因为以前从来没有使用过,只是按照一步一步记忆了操作,但总觉得不熟悉,我想是缺乏对这个软件整体的了解,真正想上手只会这一个模型也没有办法扩展。但是我感觉这些有限元分析软件学习起来应该有一些共性,基于以前对COMSOL学习的一点经验,我就在官网和其他网站找了一些学习资源构成一条基础入门之路,也可能有更好的资源,仅代表个人观点做一下分享。以上就是本人对该软件初步学习的一点理解,跟着这样的操作不到一个星期就能初步的掌握。...

怎么又是萝卜的博客 5644

【容器基础之三大基石】Cgroups、Namespace、Rootfs 保障容器的隔离性、一致性和高性能

镜像(Image):Docker 镜像(Image),就相当于是一个 root 文件系统。比如官方镜像ubuntu:16.04就包含了完整的一套 Ubuntu16.04 最小系统的 root 文件系统。容器(Container):镜像(Image)和容器(Container)的关系,就像是面向对象程序设计中的类和实例一样,镜像是静态的定义,容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等。仓库(Repository):仓库可看成一个代码控制中心,用来保存镜像。

叮当猫的喵i 2216

LDRA Testbed软件静态分析_常见问题及处理

通过前面的几篇文章,LDRA Testbed软件静态分析的内容基本讲解完了,本篇文章将针对使用Testbed进行软件静态分析的常见问题进行介绍。 到此为止,LDRA Testbed软件静态分析的内容已经全部讲完,如果有问题,欢迎私信提问(不经常登录,回复可能不及时,见谅)。下一篇文章将开始讲解如何使用Testbed进行单元测试。

文章主要涉及嵌入式软件开发、测试、项目管理等,欢迎交流,共同进步。 2593

大数据安全 | 期末复习(上)| 补档

大数据定义:无法在一定时间范围内用常规软件工具进行捕捉、管理和处理的数据集合,是需要新处理模式才能具有更强的决策力、洞察发现力和流程优化能力的海量、高增长率和多样化的信息资产。

知识库搭建ing 2590

Docker核心技术及实现原理

Linux容器最基础的两种技术:Namespace和Cgroups 容器的的本质是一种特殊的进程 Namespace的作用是”隔离“

rabies的博客 911

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

从零开始写 Docker(四)---使用 pivotRoot 切换 rootfs 实现文件系统隔离

前面几节中,我们通过Namespace和Cgroups技术创建了一个简单的容器,实现了视图隔离和资源限制。但是大家应该可以发现,容器内的目录还是当前运行程序的宿主机目录,而且如果运行一下 mount 命令可以看到继承自父进程的所有挂载点。这貌似和平常使用的容器表现不同因为这里缺少了镜像这么一个重要的特性。Docker 镜像可以说是一项伟大的创举,它使得容器传递和迁移更加简单,那么这一节会做一个简单的镜像,让容器跑在有镜像的环境中。本章会为我们切换容器的 rootfs,以实现文件系统的隔离。

探索云原生 1324

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

docker原理 容器原理 容器实现原理 - 容器四大核心技术-docker四大核心技术- 含 User Namespaces

原文:https://www.cnblogs.com/luozhiyun/p/13301664.html 容器中的进程隔离 容器技术的核心功能,就是通过约束和修改进程的动态表现,从而为其创造出一个“边界”。在Docker中使用了Namespace 技术来修改进程视图从而达到进程隔离的目的。 首先创建一个容器作为例子: $ docker run -it busybox /bin/sh / # -it 参数告诉了 Docker 项目在启动容器后,需要给我们分配一个文本输入 / 输出环境,也就是 TTY,跟容器的

yuezhilangniao的博客 1700

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

01-Docker入门与核心概念

要真正理解Docker,我们不能仅仅停留在"它是一个工具"的层面。任何一项技术的诞生都不是凭空而来的,它是对前人智慧的继承与发展,是对现实问题的回应。容器化技术同样如此——它有着超过四十年的技术积淀,经历了从chroot到LXC,再到Docker和Kubernetes的漫长演进。本章将带你穿越时光,梳理容器化技术的发展脉络,让你明白Docker为什么会出现在这个时代,以及它解决了前人没有解决好的哪些问题。软件交付方式的演进,本质上是人类对计算资源利用率和管理效率不断追求的过程。我们可以将这个过程分为三个主要

Na2SiO3Glue的博客 690

Docker 学习:术语、使用、Compose、Swarm

Docker 是一个开源的应用容器引擎,基于 Go 语言 并遵从 Apache2.0 协议开源。Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中,然后发布到任何流行的 Linux 机器上,也可以实现虚拟化。容器完全使用沙箱机制,相互之间不会有任何接口(类似 iPhone 的 app),更重要的是容器性能开销极低。

freeking101的博客 6171

深入理解Docker容器镜像

深入理解Docker容器镜像

weixin_45565886的博客 1631

从零造轮子:深入理解Docker、Git与操作系统核心原理

在软件工程领域,理解底层原理是突破技术瓶颈的关键。从基础概念出发,进程隔离、版本控制与系统调度是构建现代应用的基础。其核心原理在于通过命名空间实现资源隔离,利用内容寻址存储管理数据变更,并通过中断与调度机制协调硬件资源。这些技术的价值在于提供了高效、可复现且可扩展的开发和部署环境。在容器化部署、持续集成与系统编程等应用场景中,深入理解这些原理能帮助开发者优化性能、高效排查问题并进行合理的技术选型。本文聚焦于通过动手实践,从零实现简易容器、版本控制系统与操作系统内核,将抽象概念转化为具体代码,从而彻底掌握其设

weixin_33430573的博客 308

橘子学K8S04之重新认识Docker容器

我们今天全部的结构都可以用这个描述来体现,这个容器进程“java -jar springboot_demo-0.0.1-SNAPSHOT.jar”,运行在由 Linux Namespace 和 Cgroups 构成的隔离环境里;而它运行所需要的各种文件,比如jdk环境等等,以及整个操作系统文件,则由多个联合挂载在一起的 rootfs 层提供。这些 rootfs 层的最下层,是来自 Docker 镜像的只读层。

liuwenqiang1314的博客 1346
上一篇: ArgoWorkflow教程(一)---DevOps 另一选择?云原生 CICD: ArgoWorkflow 初体验
下一篇: 探索 Linux Namespace:Docker 隔离的神奇背后
探索云原生
博客等级 码龄9年 730粉丝 131原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值