1. Toy模板网首页
  2. > Toy博客

docker容器通俗理解

7月前 作者：安的木偶游戏 分类：Toy博客 阅读(32) 违法举报

这篇具有很好参考价值的文章主要介绍了docker容器通俗理解。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

前言

如果大家没使用过Docker,就在电脑上下载一个VMware Workstation Pro，创建一个虚拟机安装一个windows操作一下感受一下,为什么我的电脑上还以再安装一台windows主机？其实你可以理解为Docker就是Linux系统的一个虚拟机软件。

我的Windows也可以安装Docker啊？打开Docker官网https://www.docker.com/get-started/点击"Download for Window"下载一个安装查看一下。Docker在Windows上可以运行是因为Windows统提供了一种叫做 Docker Desktop for Windows的工具，它通过在Windows上创建一个Linux虚拟机来实现。Docker Desktop for Windows使用了一种叫做Hyper-V的虚拟化技术，Windows上创建了一个轻量级的Linux虚拟机，该虚拟机运行一个精简的Linux内核称为Docker宿主机。

VMware和docker

VMware和docker同样是虚拟机，但他们却有一些不同：普通虚拟化（完全型解耦）和Docker（半解耦）

耦合：耦合指的是软件组件之间的依赖关系和关联程度。
解耦：指的是减少软件组件之间的依赖关系，降低耦合度，提高代码的灵活性、可维护性和可重用性。
简单理解，就是软件之间的依赖关系紧密不紧密。
  • 普通虚拟化（完全型解耦）：每个虚拟机都拥有自己的完整操作系统和内核。这意味着虚拟机之间是完全解耦的，它们可以运行不同版本的操作系统，甚至不同类型的操作系统（例如 Linux、Windows），并且彼此之间没有任何冲突。每个虚拟机都相当于一个独立的物理服务器，可以独立地进行管理和维护。
  • 和Docker（半解耦）：在Docker中使用了一种更轻量级的容器化技术所有的容器共享宿主主机的操作系统和内核，它们之间是半解耦的。尽管容器之间共享了操作系统的核心部分，但它们仍然是相互隔离的，每个容器拥有自己的文件系统、进程空间、网络空间等。因此，容器可以运行在不同的操作系统发行版中，但它们仍然受到宿主主机操作系统的限制，并且可能会受到容器之间的冲突影响。

所以你在VMware的linux虚拟机中可以升级linux的系统内核，但是不能在Docker的容器中升级容器的系统内核。如果你的软件服务对内核版本有严格要求，这个服务就不太适合用docker来实现。

还有服务不能用Docker实现？

还有服务不能用Docker实现？一个完整的服务有可能是由多个服务在一起运行实现。开发人员开发了服务A对内核有要求需要服务器内核版本A，而开发的另一个服务B对内核也有要求需要服务器内核版本B，那么Docker就不能再同一台服务来运行A和B两个服务。这就和Docker的这种半解耦的状态有关系了。

Docker的虚拟化

Docker有个核心的组件是Containerd。在讲容器的时候大部分人会认为是容器就是Docker,我更愿意把Docker和容器分开理解，我感觉Docker和Kubernetes只是容器的管理工具而真正的容器是底层的Containerd。Docker没有Containerd组件就创建不了容器，Containerd没了Docker依然可以独立的创建容器提供服务。

docker要管理容器的生命周期

找台docker主机执行命令：docker version

[root@localhost ~]# docker version 
Client: Docker Engine - Community
 Version:           26.0.0
 API version:       1.45
 Go version:        go1.21.8
 Git commit:        2ae903e
 Built:             Wed Mar 20 15:21:09 2024
 OS/Arch:           linux/amd64
 Context:           default

Server: Docker Engine - Community
 Engine:
  Version:          26.0.0
  API version:      1.45 (minimum version 1.24)
  Go version:       go1.21.8
  Git commit:       8b79278
  Built:            Wed Mar 20 15:20:06 2024
  OS/Arch:          linux/amd64
  Experimental:     false
 containerd:
  Version:          1.6.28
  GitCommit:        ae07eda36dd25f8a1b98dfbf587313b99c0190bb
 runc:
  Version:          1.1.12
  GitCommit:        v1.1.12-0-g51d5e94
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0

我们看到docker有两个重要的组件docker引擎Client、Server：

  • Client：是与用户交互的主要方式，它提供了一个命令行界面（CLI）和API，使得用户可以使用Docker来构建、运行和管理容器化的应用程序。用户可以通过Docker CLI命令（例如 docker run、docker build）通过 Docker API来向Server发送请求。
  • Server：是一个后台运行的进程，负责管理Docker上的容器、镜像、网络和存储等资源。它是Docker引擎的核心组件之一，负责接收来自 Docker客户端的请求，并根据这些请求来创建、启动、停止、删除容器，以及构建、拉取、推送镜像等操作。它还通过与containerd进行通信来管理容器的生命周期。
    docker容器通俗理解,Docker,#容器,docker,Cgroup

docker：的基本架构

  1、 doker分为用户端和服务器端：我们刚刚已经查看过了。 Server为客户端提供UESTfulAPI,响应来自客户端的请求采用模块化的架构，通过专门的Engine模块来分发管理各个来自客户端的任务。
  2、docker-proxy：是dockerd的子进程，当需要进行容器映射的时候docker-proxy完成网络映射配置。
  3、containerd：是dockerd的子进程提供GRPC接口来响应来自dockerd的请求，对下管理runC镜像和容器环境。
  4、containerd-shim:是dockerd的子进进程为Runc容器提供支持同事作为容器的根进程。

docker的隔离策略

docker是半耦合的虚拟化，那么它是如何实现隔离的呢？Docker的隔离主要是通过Linux内核提供的一系列的特性来实现的.
进入linux系统在进入任意进程查看一下：cd /proc/2538/ns | ll

[root@localhost ns]# pwd 
/proc/2538/ns
[root@localhost ns]# ll
总用量 0
lrwxrwxrwx. 1 bwk root 0 4月  27 15:26 ipc -> ipc:[4026532679]
lrwxrwxrwx. 1 bwk root 0 4月  27 15:26 mnt -> mnt:[4026532677]
lrwxrwxrwx. 1 bwk root 0 4月  27 15:26 net -> net:[4026532682]
lrwxrwxrwx. 1 bwk root 0 4月  27 15:26 pid -> pid:[4026532680]
lrwxrwxrwx. 1 bwk root 0 4月  27 15:26 user -> user:[4026531837]
lrwxrwxrwx. 1 bwk root 0 4月  27 15:26 uts -> uts:[4026532678]

基于此Docker有六项隔离实现了容器与宿主机、容器与容器之间的隔离：

IPC: 信号量、消息队列和共享内存
MNT: 挂载点、文件系统
NET: 网络设备、网络栈、端口等等
PID: 进程编号
USER: 用户、组
UTS: 主机名、域名

主要包括以下几个方面：

  • 命名空间（Namespace）： Docker使用Linux内核的命名空间机制来隔离容器的进程视图、网络、文件系统、用户、主机名等资源。每个容器都有自己独立的命名空间，使得容器内的进程无法感知到其他容器或宿主机上的进程，从而实现了进程级别的隔离。
  • 控制组（Cgroup）： Docker使用Linux内核的控制组机制来限制容器对 CPU、内存、磁盘、网络等资源的使用。通过将容器的资源限制和监控与控制组关联起来，Docker 可以有效地管理和调度容器的资源使用，防止容器占用过多的系统资源，从而确保系统的稳定性和可靠性。
  • 容器文件系统（Union File System）： Docker使用联合文件系统（Union File System）来实现容器的文件系统隔离。联合文件系统允许容器在一个只读的基础文件系统上叠加多个可写的文件系统层，使得容器内的文件系统与宿主机和其他容器的文件系统相互隔离，同时可以实现文件系统的共享和复用。
  • 网络隔离： Docker使用Linux内核的网络命名空间来实现容器之间的网络隔离。每个容器都有自己独立的网络命名空间，使得容器可以拥有自己独立的网络接口、IP 地址和路由表，从而实现了网络层面的隔离。

1、命名空间（Namespace）
我的docker运行了一个Elasticsearch集群：
命名空间有六项隔离，我们查看一下：es01有映射端口是9200

[root@localhost docker]# ps -ef | grep 9200
root       3744   1501  0 16:32 ?        00:00:00 /usr/bin/docker-proxy -proto tcp -host-ip 0.0.0.0 -host-port 9200 -container-ip 172.18.0.4 -container-port 9200
root       3750   1501  0 16:32 ?        00:00:00 /usr/bin/docker-proxy -proto tcp -host-ip :: -host-port 9200 -container-ip 172.18.0.4 -container-port 9200
root       4098   1418  0 16:43 pts/0    00:00:00 grep --color=auto 9200
[root@localhost docker]# ps -ef | grep 1501
root       1501      1  0 11:36 ?        00:00:29 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
root       3744   1501  0 16:32 ?        00:00:00 /usr/bin/docker-proxy -proto tcp -host-ip 0.0.0.0 -host-port 9200 -container-ip 172.18.0.4 -container-port 9200
root       3750   1501  0 16:32 ?        00:00:00 /usr/bin/docker-proxy -proto tcp -host-ip :: -host-port 9200 -container-ip 172.18.0.4 -container-port 9200
root       4100   1418  0 16:44 pts/0    00:00:00 grep --color=auto 1501

一个映射ipv4一个映射ipv6进程是3744和3750，我们看到两个9200的进程有同一个父进程1501并且这个正是docker的主进程。
那么在容器内部是怎么样的呢?

[root@localhost ns]# docker exec -it es01 /bin/bash
root@e67d6d5de8b2:/usr/share/elasticsearch# ps aux 
USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root          1  0.0  0.0   2484   312 ?        Ss   16:32   0:00 /bin/tini -- /usr/local/bin/docker-entrypoint.sh eswrapper
elastic+      7  4.8 26.9 4272660 1040204 ?     SLl  16:32   1:23 /usr/share/elasticsearch/jdk/bin/java -Xshare:auto -Des.networkaddress.cache.ttl=60 -Des.networkaddres
elastic+    209  0.0  0.1 108392  4600 ?        Sl   16:32   0:00 /usr/share/elasticsearch/modules/x-pack-ml/platform/linux-x86_64/bin/controller
root        253  3.7  0.0   4100  2164 pts/0    Ss   17:01   0:00 /bin/bash
root        263  0.0  0.0   5884  1476 pts/0    R+   17:01   0:00 ps aux

在容器内部完全是独立的系统进程，宿主机看到的是3744和3750，3744和3750在/proc/3744/ns中六项均都指向的是同一样的命名空间标识符其实是一个服务。

2、控制组（Cgroup）
Cgroup（Control Group）是属于linux的内核提供的一个特性，用于限制和隔离一组进程对系统资源的使用。

它的作用：

1）资源限制，可以将组设置一定的内存限制。
2）优先级，通过优先级让一些组优先获得更多资源。
3）资源审计，用来统计系统实际上把多少资源用到适合的目的上。
4）隔离，为组隔离命名空间，这样使得一个组不会看到另一个组的进程、网络链接和文件系统。
4）控制，执行挂起、恢复、和重启等操作。
devices:设备权限控制。
cpuset:分配指定的cpu和内存
cpu：控制cpu占用率。
cpuacct：统计cpu使用情况 
memory：限制内存使用情况。
freezer：冻结（暂停）Cgroup中的进程  
net_prio: 设置进程的网络流量优先级。
huge_tlb:限制HugeTLB的使用。
perf_event:允许perfect工具基于Cgroup分组做性能监测。

Cgroup是一个虚拟的文件系统，在Linux发行版中系统启动时已经完成挂载。

[root@python ~]# mount | grep cgroup
tmpfs on /sys/fs/cgroup type tmpfs (ro,nosuid,nodev,noexec,mode=755)
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/blkio type cgroup (rw,nosuid,nodev,noexec,relatime,blkio)
cgroup on /sys/fs/cgroup/freezer type cgroup (rw,nosuid,nodev,noexec,relatime,freezer)
cgroup on /sys/fs/cgroup/perf_event type cgroup (rw,nosuid,nodev,noexec,relatime,perf_event)
cgroup on /sys/fs/cgroup/devices type cgroup (rw,nosuid,nodev,noexec,relatime,devices)
cgroup on /sys/fs/cgroup/net_cls,net_prio type cgroup (rw,nosuid,nodev,noexec,relatime,net_prio,net_cls)
cgroup on /sys/fs/cgroup/memory type cgroup (rw,nosuid,nodev,noexec,relatime,memory)
cgroup on /sys/fs/cgroup/pids type cgroup (rw,nosuid,nodev,noexec,relatime,pids)
cgroup on /sys/fs/cgroup/cpu,cpuacct type cgroup (rw,nosuid,nodev,noexec,relatime,cpuacct,cpu)
cgroup on /sys/fs/cgroup/hugetlb type cgroup (rw,nosuid,nodev,noexec,relatime,hugetlb)
cgroup on /sys/fs/cgroup/cpuset type cgroup (rw,nosuid,nodev,noexec,relatime,cpuset)

在/sys/fs/cgroup/下相应的属性文件下都有一个docker的目录里面存放生成的容器隔离文件。太多自己可以查看一下。

[root@localhost cgroup]# pwd
/sys/fs/cgroup
[root@localhost cgroup]# ls
blkio  cpu  cpuacct  cpu,cpuacct  cpuset  devices  freezer  hugetlb  memory  net_cls  net_cls,net_prio  net_prio  perf_event  pids  systemd

Cgroup子系统介绍简单理解：

 1、cpuset子系统
      cpuset.cpus 允许进程使用的CPU列表（例如0~4，9）
      cpuset.mems 允许进程使用的内存列表 (例如：0~1)
 2、cpu子系统
      用于限制进程cpu占用率，有三个功能分别通过不同的接口来实现。
       1)cpu比重分配：接口cpu.shares。假设在cgroupfs的根目录下创建（C1、C2）并且cpu.shares分别配置512和1024.那么在C1和C2使用cpu时候c2将比c1使用多一倍的cpu使用率，只有当他们争用cpu的时候才起效。
       2)cpu带宽限制：接口cpu.cfs_quota_us。接口单位是微秒。可以将period设置为1秒将quota设置为0.5秒。那么Cgroup中的进程在1秒内最多只能运行0.5秒然后被强制睡眠直到进入到下一个1秒。实时进程的带宽限制：接口cpu.rt_peri-od_us和cpu.rt_runtime_us。
  3、cpuacct子系统
       用来统计cpu的使用情况。
  4、memory子系统
       memory子系统用来限制Cgroup所能使用的内存上限 接口memory.limit_in_bytes。单位k/K、m/M或者g/G表示
         echo 1G > memory.limit_in_bytes
       memory.memsw.lim-it_in_bytes 设定内存加交换分区的使用总量。防止进程用尽交换分区。
       memory.oom_control: 如果设置为0，那么在内存使用量超过上限时不会杀死进程，而是阻塞进程直到内存释放可供使用。另一方面系统会向用户发送通知用户的监控程序可以根据该事件来做相应处理。
       memory.stat: 汇报内存使用信息。
  5、blkio 子系统
       用来限制Cgroup的block I/O带宽。（就是磁盘IO）
       .blkio.weight: 设置权重值，范围100~1000。和cpu.shares类似，是比重分配，不是绝对资源限制，只有在Cgroup在争用同一块设备时候才起作用。
       .blkio.weight_device对具体的设备设置权重值，这个值会覆盖blkio.weight。
   6、devices子系统
       用来控制Cgroup的进程对那些设备具有访问权限。
       .devices.list 只读文件显示目前允许访问的设备列表。每个条目分3个域。 
          1）类型：可以是a、c或b，分别表示所有设备、字符设备、块设备。
          2）设备号 
          3）权限r、w或m的组合分别表示可读、可写、可创建设备节点。
       .devices.allow 只写文件，以上描述的格式写入文件，就可以允许相应的设备访问权限。
       .devices.deny 只写文件，以上描述的格式写入该文件，就可以禁止相应的设备访问权限。

我们用memroy看一下：

[root@localhost /]# docker ps -a 
CONTAINER ID   IMAGE                                                   COMMAND                   CREATED       STATUS       PORTS                                                 NAMES
e67d6d5de8b2   docker.elastic.co/elasticsearch/elasticsearch:7.17.14   "/bin/tini -- /usr/l…"   3 weeks ago   Up 5 hours   0.0.0.0:9200->9200/tcp, :::9200->9200/tcp, 9300/tcp   es01
55d5e73f9a94   docker.elastic.co/elasticsearch/elasticsearch:7.17.14   "/bin/tini -- /usr/l…"   3 weeks ago   Up 5 hours   9200/tcp, 9300/tcp                                    es02
53f7c8128cc1   docker.elastic.co/elasticsearch/elasticsearch:7.17.14   "/bin/tini -- /usr/l…"   3 weeks ago   Up 5 hours   9200/tcp, 9300/tcp                                    es03

看一下es01的内存配置这个内存我是没做任何限制，表示容器可以使用宿主机上的全部可用内存：

[root@localhost /]# docker inspect es01 --format='{{.HostConfig.Memory}}'
0

查看一下容器ID：

[root@localhost ~]# docker inspect es01
[
    {
        "Id": "e67d6d5de8b273e69fbc806d303f1bea169941779ade044be2081f488f5db5ba",
        "Created": "2024-04-04T13:56:18.043205656Z",

在/sys/fs/cgroup/memory/docker目录下：

[root@localhost docker]# ll
总用量 0
drwxr-xr-x. 2 root root 0 4月  27 11:36 53f7c8128cc1a1117e4ec0b521d8fcc4c6ca4df490f5ac44c8463b5cf19920ac
drwxr-xr-x. 2 root root 0 4月  27 11:36 55d5e73f9a94677e00fa5a4a77e492a312fe1ab7101f27000b7c2b6f59c2956c
-rw-r--r--. 1 root root 0 4月  27 11:36 cgroup.clone_children
--w--w--w-. 1 root root 0 4月  27 11:36 cgroup.event_control
-rw-r--r--. 1 root root 0 4月  27 11:36 cgroup.procs
drwxr-xr-x. 2 root root 0 4月  27 11:36 e67d6d5de8b273e69fbc806d303f1bea169941779ade044be2081f488f5db5ba

进入到虚拟目录：

[root@localhost e67d6d5de8b273e69fbc806d303f1bea169941779ade044be2081f488f5db5ba]# cat memory.limit_in_bytes 
9223372036854771712
[root@localhost e67d6d5de8b273e69fbc806d303f1bea169941779ade044be2081f488f5db5ba]# echo 1G > memory.limit_in_bytes
[root@localhost e67d6d5de8b273e69fbc806d303f1bea169941779ade044be2081f488f5db5ba]# cat memory.limit_in_bytes 
1073741824

实际上我们对内存做了1G的限制。重启容器：

[root@localhost e67d6d5de8b273e69fbc806d303f1bea169941779ade044be2081f488f5db5ba]# docker restart es01
es01
[root@localhost e67d6d5de8b273e69fbc806d303f1bea169941779ade044be2081f488f5db5ba]# ls
[root@localhost e67d6d5de8b273e69fbc806d303f1bea169941779ade044be2081f488f5db5ba]# cd ..
[root@localhost docker]# cd e67d6d5de8b273e69fbc806d303f1bea169941779ade044be2081f488f5db5ba/
[root@localhost e67d6d5de8b273e69fbc806d303f1bea169941779ade044be2081f488f5db5ba]# cat memory.limit_in_bytes 
9223372036854771712

因为他是虚拟文件，重启后目录下文件消失，恢复docker默认设置。文章来源地址https://www.toymoban.com/news/detail-861210.html

哪些是耦合的

  • 共享内核：Docker 容器与宿主机共享同一个内核，因此容器内部的进程直接运行在宿主机的内核之上。这种共享内核的特性导致容器与宿主机之间有一定的耦合性，容器的行为受限于宿主机的内核版本和配置。
  • 资源：虽然 Docker 容器提供了一定程度的资源隔离，如 CPU、内存和网络等，但是由于容器与宿主机共享同一个内核，因此容器之间的资源隔离并不是完全隔离的。例如，在容器内部可以通过一些技巧访问到宿主机的资源，将宿主机上的某些目录挂载到容器内部，以便与宿主机共享文件或配置。
  • 网络：Docker 容器提供了一定程度的网络隔离，每个容器都有自己独立的网络栈和网络命名空间。但是由于容器共享宿主机的网络设备，因此容器之间仍然可以相互通信，容器的网络行为也受限于宿主机的网络配置。

到了这里，关于docker容器通俗理解的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 【Docker】深入理解Docker：一种革新性的容器技术

    【Docker】深入理解Docker：一种革新性的容器技术

    前言   Docker 是一个 开源的应用容器引擎 ，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中,然后发布到任何流行的 Linux或Windows 操作系统的机器上,也可以实现虚拟化,容器是完全使用沙箱机制,相互之间不会有任何接口。 📕作者简介： 热爱跑步的恒川 ，致

    2024年02月05日
    浏览(43)
  • Docker网络模型：理解容器网络通信和连接

    Docker网络模型：理解容器网络通信和连接

    🌷🍁 博主猫头虎 带您 Go to New World.✨🍁 🦄 博客首页——猫头虎的博客🎐 🐳《面试题大全专栏》 文章图文并茂🦕生动形象🦖简单易学！欢迎大家来踩踩~🌺 🌊 《IDEA开发秘籍专栏》学会IDEA常用操作，工作效率翻倍~💐 🌊 《100天精通Golang(基础入门篇）》学会Golang语言

    2024年02月14日
    浏览(65)
  • 面向对象视角下，理解Docker 镜像容器和仓库

    面向对象视角下，理解Docker 镜像容器和仓库

    今天带大家在面向对象的视角下，理解镜像，容器和仓库到底是什么关系，相信大家读完本文一定会有更深刻的理解。 注：面向对象语言有很多，本文基于Java语言进行描述 首先创建一个类，用来模拟 Docker 中的一个镜像 tomcat8，其中暴露了一个获取版本号和启动的方法 创建

    2024年01月19日
    浏览(44)
  • docker cgroup资源占用及docker的镜像创建

    docker cgroup资源占用及docker的镜像创建

    基本复写了常见的资源配额和使用量控制 cgroup是controlgroup的缩写 设置cpu使用率的上限 linux通过cfs（完全公平调度器）来调度各个进程对cpu的使用，cfs默认的调度周期是100ms 我们可以设置每个容器进程的调度周期，以及再这个周期内各个容器最多能使用cpu时间。 cpu分多少时间

    2024年02月08日
    浏览(46)
  • docker之cgroup版本问题

    docker之cgroup版本问题

    docker容器无法启动，报错 Failed to mount cgroup at /sys/fs/cgroup/systemd: Operation not permitted · Issue #4072 · lxc/lxc Linux 5.x  及以上内核改用了  cgroup v2  版本，而容器镜像环境需要的还是  cgroup v1  版本。 同时由于  cgroup v2  和  v1  不能兼容，因此导致容器启动后，容器内相关服务无

    2024年01月24日
    浏览(40)

  • 十七、Docker之Cgroup资源配置

    其实在日常的工作中，我们一般都没有对docker容器进行资源限制，也就是默认情况下，可以使用宿主机的所有资源。但是如果你运行的服务有问题，就有可能对宿主机和宿主机上的其他业务造成影响，这还是有一定的风险。那么本文会给大家介绍一下如何对容器进行资源配置

    2024年02月16日
    浏览(48)
  • docker核心原理——unionfs、namespace、cgroup

    docker核心原理——unionfs、namespace、cgroup

    docker的核心原理其实就是cgroup+namespace+unionfs 组合实现的隔离机制，资源控制等。 隔离机制 在容器进程启动之前重新挂载它的整个根⽬录“/”，⽤来为容器提供隔离后的执⾏环境⽂件系统 通过Linux Namespace 创建隔离，决定进程能够看到和使⽤哪些东⻄。 通过control groups 技术来

    2024年02月04日
    浏览(64)
  • 【云原生】Docker网络及Cgroup资源控制

    【云原生】Docker网络及Cgroup资源控制

    Docker使用Linux桥接，在宿主机虚拟一个Docker容器网桥(docker0)，Docker启动一个容器时会根据Docker网桥的网段分配给容器一个IP地址，称为Container-IP，同时Docker网桥是每个容器的默认网关。因为在同一宿主机内的容器都接入同一个网桥，这样容器之间就能够通过容器的 Container-IP 直

    2024年02月16日
    浏览(43)

  • Docker底层原理：Cgroup V2的使用

    若系统没有加载cgroup2文件系统，需要执行下面这条命令

    2024年02月06日
    浏览(44)
  • 【Docker】如何编写Dockerfile，深入理解 Dockerfile：构建精简且高效的容器镜像

    【Docker】如何编写Dockerfile，深入理解 Dockerfile：构建精简且高效的容器镜像

    Docker 是一种轻量级的容器化技术，使得应用程序和它们的依赖可以被打包到一个容器中，方便在不同环境中运行。Dockerfile 是用于定义 Docker 镜像的文本文件，其中包含了一系列的指令，这些指令描述了镜像中应该包含哪些内容和如何配置。 在开始编写 Dockerfile 之前，确保你

    2024年01月24日
    浏览(54)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包