虚拟化+Docker 概念基本介绍

容器是一种技术，开发人员打包开发完成的一个应用（系统）以及所需的开发环境，然后通过容器可以运行在不同的计算机上面，也不需要重新配置相关环境，不同的是每一台计算机都需要配置运行容器的容器引擎，目前市场上主流就是Docker容器引擎，不过Docker容器引擎的配置很简单，比配置应用（系统）运行的环境简单，方便太多。每台要运行应用（系统）的计算机上面配置了Docker容器引擎之后，都单独独立可以运行之前打包完成的应用（系统）。

以linux而言，linux操作系统会有一个主进程pid=1派生出其他进程来控制不同服务

例如:

pid=2 ——> python
pid=3——>java
pid=4——>php

三个服务可能会相互影响

使用者期望将这三个不同的服务，跑在不同的运行时环境中实现相互不影响，同时不会增加服务器成本

延伸出——>能否将这三种服务分别封装起来——>KVM虚拟化技术，实现了一个操作系统模拟多个操作系统/不同的运行时环境
随着技术发展——>虚拟化技术开销较大(例如:只要运行一个py脚本，想要使用虚拟化方式实现，还需要安装一个操作系统，并不方便/合理)

——>延伸出容器技术
虚拟化层的抽象层(用户层)剥离，使用docker engine来替代(来bin操作系统去除)，只要通过引擎就可以直接连接到宿主机操作系统中，极大减小了开销。

一、虚拟化

1、虚拟化概述

虚拟化，是指通过虚拟化技术将一台计算机虚拟为多台逻辑计算机。在一台计算机上同时运行多个逻辑计算机，每个逻辑计算机可运行不同的操作系统，并且应用程序都可以在相互独立的空间内运行而互相不影响，从而显著提高计算机的工作效率。

简单来说

虚拟化：就是将应用程序和系统内核资源进行解耦，以操作系统级别进行隔离，目的是提高资源利用率

虚拟化使用软件的方法重新定义划分 IT 资源，可以实现 IT 资源的动态分配、灵活调度、跨域共享，提高 IT 资源利用率，使 IT 资源能够真正成为社会基础设施，服务于各行各业中灵活多变的应用需求。

在一个操作系统中（win10）模拟多个操作系统（centos、win10、suse），
同时每个操作系统可以跑不同的服务（nginx+tomcat）,从而实现一台宿主机搭建一个集群（从整体）。
通过软件/应用程序的方式，来实现物理硬件的功能。
例如ensp,以软件形式实现物理设备的功能（二层交换机、路由器、三层交换机等）。

2、耦合与解耦合

耦合性是程序结构中各个模块之间相互关联的度量。它取决于各个模块之间的接口的复杂程度、调用模块的方式以及哪些信息通过接口。

耦合是项目模块之间的关联度高及相互依赖程度高，
也就是说我们在后期项目修改时，如果耦合度高的话，这样会牵一发而动全身，增加了相应的维护成本
相反，解耦合就是要降低这种模块之间的相互依赖程度，降低维护成本与复杂度。

2.1、耦合

耦合是指两个或两个以上的体系或两种运动形式间通过相互作用而彼此影响以至联合起来的现象。

对象之间的耦合度就是对象之间的依赖性。

对象之间的耦合越高，维护成本越高

2.2、解耦合

字面意思就是解除耦合关系。

在软件工程中，降低耦合度即可以理解为解耦，模块间有依赖关系必然存在耦合，理论上的绝对零耦合是做不到的，但可以通过一些现有的方法将耦合度降至最低。

3、CPU的时间分片（CPU虚拟化）

正常每个任务以轮询的方式去处理，这个时候一个CPU一个整体。
以下是针对的CPU单位时间内的一个资源。按时间划分，1秒划分成10个0.1秒，
每个0.1秒可以全力处理10单位的任务。在1秒内，都在全力工作。

cpu 1s全力运转的性能——》逻辑分割成分成了10份，可以理解为在单位时间内可以处理10个任务，
每一个0.1s cpu是满的。原先分片前100M以下的任务一次只可以处理1个，现在100M的任务一次可以处理10个。这就是时间分片的一个概念。

4、虚拟化作用

缓解/解决了资源利用率的问题

物理硬件的性能就会比虚拟化的性能高,在极度吃资源的情况下，例如mysql高并发这种，就不适合用虚拟化。

5、虚拟化工作原理

虚拟机管理器功能：调用资源

两大核心组件：QEMU、KVM

5.1、QEMU

QEMU是I/O控制的模块，可以理解为队列，核心目的是调用资源内核中的资源，需要把KVM逻辑分割出来的资源运输给QEMU，再给虚拟机。
QEMU它并不是直接调用，而是用I/O方式调用，QEMU把资源调用来的过程借用ioctl，QEMU借助libvirt这个工具调用ioctl，再通过接口，给虚拟机应用程序。

5.2、KVM

用来逻辑分割物理资源，抽象化为虚拟化资源，根据VMM里的配置，会逻辑分割出多少G，给应用程序，去进行虚拟化。
只接受来自QEMU的请求指令。对于应用程序直接过来的敏感指令会拦截，然后通过接口发给QEMU，让QEMU判断是否需要执行，可以的话，再下来，不可以的话，打回去，不执行该敏感指令。

对于workstation而言——》硬件辅助虚拟化，表现形式在处理器里面有一个虚拟化引擎，
可以勾取硬件辅助虚拟化，看到虚拟接口/dev/kvm，可以加强辅助调用，
在应用程序需要频繁调用的时候，需要开启。比如openstack。

5.3、虚拟化类型

全虚拟化：将物理硬件资源全部通过软件的方式抽象化，最后进行调用

半虚拟化：需要修改操作系统

直通:直接使用物理硬件资源（需要支持，还不完善)

全虚拟化：KVM——》产品vmware—ce

半虚拟化：EXSI——》workststion vsphere

5.4、虚拟化的功能

在一个操作系统内，模拟多个操作系统

以软件的方式模拟物理设备的功能

二、Docker 概述

云计算涌现出很多改变传统IT架构和运维方式的新技术，比如虚拟机、容器、微服务、Serverless（无服务），无论这些技术应用在哪些场景，降低成本、提升效率是云服务永恒的主题。

容器基础概念—>六大名称空间
名称空间：以不同空间划分不同资源

1、docker是什么？

Docker 是一个开源的应用容器引擎，基于 go 语言开发并遵循了 apache2.0 协议开源。
Docker 是在 Linux 容器里运行的开源工具，是一种轻量级的虚拟机。
Docker 的容器技术可以在一台主机上轻松为任何应用创建一个轻量级的、可移植的、自给自足的容器。

是一种轻量级的“虚拟机”，docker是一个用于开发，交付和运行应用程序的开放平台。

在Linux容器里运行应用的开源工具—》容器引擎，让开发者可以打包大量的应用以及依赖包到一个可以值得镜像中，然后发布到任何流行的Linux或者window机器中。

docker的logo设计为蓝色鲸鱼，拖着许多集装箱。
鲸鱼可以作为宿主机，集装箱可理解为相互隔离的容器，每个集装箱中都包含自己的应用程序。

2、Docker的设计宗旨

build，ship and run any App，Anywhere 即通过对应用组件的封装、发布、部署、运行等生命期的管理，达到应用组件级别的“一次封装，到处运行”的目的。这里的组件，既可以是一个应用，也可以是一套服务，甚至是一个完整的操作系统。

3、Docker特点

容器化越来越受欢迎，因为容器是：

灵活：即使是最复杂的应用也可以集装箱化。

轻量级：容器利用并共享主机内核。

可互换：可以即时部署更新和升级。

便携式：可以在本地构建，部署到云，并在任何地方运行。

可扩展：可以增加并白动分发容器副本。

可堆叠：可以垂直和即时堆叠服务。

容器是在linux上本机运行，并与其他容器共享主机的内核，它运行的是一个独立的进程，不占用其他任何可执行文件的内存，非常轻量。

虚拟机运行的是一个完整的操作系统，通过虚拟机管理程序对主机资源进行虚拟访问，相比之下需要的资源更多。

4、Docker的优势和意义

把容器化技术做成了标准化平台

docker引擎统一了基础设施环境——docker环境
docker引擎统一了程序打包（装箱) 方式——docker镜像（把引擎放在镜像中，带着镜像到处跑）
docker引擎统一了程序部署（运行）方式——docke容器（利用引擎把这个镜像再去运行为之前的相同的一模一样的容器了）

镜像——》封装的一个时刻的服务/应用状态
容器——》应用跑起来的状态（正常提供服务的状态 - 运行时
有镜像才能有容器

实现了一次构建，多次、多处使用。

5、容器与KVM（虚拟机）的区别

5.1、隔离与共享

虚拟机通过添加Hypervisor层（虚拟化中间层），虚拟出网卡、内存、CPU等虚拟硬件，再在其上建立虚拟机，每个虚拟机都有自己的系统内核。而Docker容器则是通过隔离（namesapce）的方式，将文件系统、进程、设备、网络等资源进行隔离，再对权限、CPU资源等进行控制（cgroup），最终让容器之间互不影响，容器无法影响宿主机。

容器与宿主机共享内核、文件系统、硬件等资源。

5.2、性能与损耗

与虚拟机相比，容器资源损耗要少。
同样的宿主机下，能够建立容器的数量要比虚拟机多
但是，虚拟机的安全性要比容器稍好，要从虚拟机攻破到宿主机或其他虚拟机，需要先攻破 Hypervisor层，这是极其困难的
而docker容器与宿主机共享内核、文件系统等资源，更有可能对其他容器、宿主机产生影响。

不同点	容器	虚拟机
启动速度	快，几秒钟	慢，几分钟
运行性能	接近原生（直接在内核中运行）	运行于Hypervisor上，50%左右损失
磁盘占用	小，甚至几十KB（根据镜像层的情况）	非常大，上GB
并发性	一台宿主机可以启动成百上千个容器	最多几十个虚拟机
隔离性	进程级别	资源隔离/限制
磁盘占用	小，甚至几十KB（根据镜像层的情况）	非常大，上GB
并发性	一台宿主机可以启动成百上千个容器	最多几十个虚拟机
隔离性	进程级别	资源隔离/限制

三、Docker的使用场景

打包应用程序部署简单

可脱离底层硬件任意迁移（实现了应用的隔离，将应用拆分并进行解耦）
例如： 需要把服务器从腾讯云迁移到阿里云，如果采用的是 Docker 容器技术
整个迁移的过程只需要在新的服务器上启动我们需要的容器就可以了。

适合做微服务的部署
提供PASS产品（平台即服务）{OpenStack的云主机类似于阿里云的ECS，
属于IAAS、Docker(K8S)属于PAAS}

适合持续集成和持续交付（CI/CD）:开发到测试发布

四、Docker引擎（Docker Engine）

Docker Engine是具有以下主要组件的**客户端-服务器（C/S架构）**应用程序:

server端：服务器是一种长期运行的程序，称为守护程序进程( dockerd命令）。

client端：REST API，它指定程序可以用来与守护程序进行通信并指示其操作的接口。

命令行界面(cLI）客户端（(docker命令）。

五、Docker容器概述

1、Docker的架构（Docker architecture）

Docker使用客户端-服务端（C/S）架构。Docker客户端与Docker守护进程进行对话，该守护进程完成了构建，运行和分发Docker容器的繁重工作。

Docker区别于传统的虚拟化，不需要虚拟硬件资源，直接使用容器引擎，所以速度快。

Docker daemon:守护进程

Docker守护程序（dockerd）侦听Docker API请求并管理Docker对象。例如图像、容器、网络和卷，守护程序还可以与其他守护程序通信以管理Docker服务。

2、简述Docker体系架构

Docker客户端 - Docker

docker客户端则扮演着docker服务端的远程控制器，可以用来控制docker的服务端进程。

Docker服务端-Docker Daemon资源限制

docker服务端是一个服务进程，管理着所有的容器。

Docker镜像一Imagefont>

Docker的镜像是创建容器的基础，类似虚拟机的快照，可以理解为一个面向Docker容器引擎的只读模板。通过镜像启动一个容器，一个镜像是一个可执行的包,其中包括运行应用程序所需要的所有内容包含代码。运行时间，库，环境变量，和配置文件

Docker容器-Docker Container

Docker的容器是从镜像创建的运行实例，它可以被启动、停止和删除。所创建的每一个容器都是相互隔离、互不可见，以保证平台的安全性。

Docker镜像仓库-- Registryfont>

Docker仓库是用来集中保存镜像的地方,当创建了自己的镜像之后，可以使用push命令将它上传到公有仓库(Public)或者私有仓库(Private、常用）。当下次要在另外一台机器上使用这个镜像时，只需从仓库获取。

Docker的镜像、容器、日志等内容全部都默认存储在/var/lib/docker目录下。

3、Docker 三要素（核心组件）

Docker images:镜像：统一的封装方式——》模板

Docker container:容器：统一的运行时环境 ——》基于镜像，运行状态/运行时状态

Docker registry:镜像仓库：放置镜像的仓库——》存放镜像模板

存储镜像的地方，默认在公共的 Docker Hub上查找，可以搞个人仓库。

仓库大类：①公共仓库—》docker hub ②私有仓库registry harbor

4、Docker运行流程

工作流程：

客户端发起各种各样的命令，给与主机
build：制作镜像（image）
pull：拉取镜像（拉倒本地去使用）
run：运行容器的（docker）

主机会调用镜像，如果有镜像直接用，运行为容器
如果镜像里没有会到registry公共仓库去拉去镜像，拉到本地后再运行为容器

5、namespace （名称空间）

namespace资源隔离——用容器技术封装

mount	文件系统，挂载点——>一个文件系统内，不能重复挂载一个指定目录
user	操作进程的用户和用户组
pid	进程编号
uts	主机名和主机域（同一个环境里不能又叫node1又叫node2）
ipc	信号量、消息队列、共享内存(不同的应用调用内存资源的时候应该使用不同的内存空间)
net（网络资源）	网络设备、网络协议栈（在同一个网络名称空间中的网络规则）、端口等

6、资源控制——cgroups

六种名称空间是由cgroups管理的
最后一种centos的cgroups管理版本是3.8版本，3.6和3.5已经不用了

cgroups 管理linux内核态中资源管理的模块

cgroups 管理一些系统资源

不是docker原生的。

【CPU为什么能够划分时间片，就是通过cgroups去划分管理的】

Linux上的Docker引擎还依赖于另一种称为控制组（cgroups）的技术。cgroup将应用程序限制为一组特定的资源。控制组允许Docker Engine将可用的硬件资源共享给容器，并有选择地实施限制和约束。例如，您可以限制特定容器可用的内存。

7、容器小的架构体系

（存储引擎)overlay2（现在使用）和（存储引擎) aufs（早期使用）叠加式文件系统

docker引擎统—了程序部署(运行)方式-docker容器——>基于镜像——>运行为容器(可运行的环境)

实现了一次构建，多次、多处使用

六、总结

容器的概念：容器是一种数据类型，是序列，存储大量的数据，学习容器的意义:容器可以改变变量只能存储单个数据的缺陷

原文链接：https://blog.csdn.net/weixin_56270746/article/details/125751186

最后修改：2023 年 10 月 26 日

如果觉得我的文章对你有用，请随意赞赏

此处评论已关闭

虚拟化+Docker 概念基本介绍

Atigger • 2023 年 10 月 26 日

<div id="content_views" class="htmledit_views"><p id="main-toc"><strong>目录</strong></p><p id="%E5%89%8D%E8%A8%80%EF%BC%9A%E2%80%8B%E7%BC%96%E8%BE%91-toc" style="margin-left:80px;"><a href="#%E5%89%8D%E8%A8%80%EF%BC%9A%E2%80%8B%E7%BC%96%E8%BE%91">前言：</a></p><p id="%C2%A0%E4%B8%80%E3%80%81%E8%99%9A%E6%8B%9F%E5%8C%96-toc" style="margin-left:0px;"><a href="#%C2%A0%E4%B8%80%E3%80%81%E8%99%9A%E6%8B%9F%E5%8C%96">&nbsp;一、虚拟化</a></p><p id="1%E3%80%81%E8%99%9A%E6%8B%9F%E5%8C%96%E6%A6%82%E8%BF%B0-toc" style="margin-left:40px;"><a href="#1%E3%80%81%E8%99%9A%E6%8B%9F%E5%8C%96%E6%A6%82%E8%BF%B0">1、虚拟化概述</a></p><p id="2%E3%80%81%E8%80%A6%E5%90%88%E4%B8%8E%E8%A7%A3%E8%80%A6%E5%90%88-toc" style="margin-left:40px;"><a href="#2%E3%80%81%E8%80%A6%E5%90%88%E4%B8%8E%E8%A7%A3%E8%80%A6%E5%90%88">2、耦合与解耦合</a></p><p id="2.1%E3%80%81%E8%80%A6%E5%90%88-toc" style="margin-left:80px;"><a href="#2.1%E3%80%81%E8%80%A6%E5%90%88">2.1、耦合</a></p><p id="2.2%E3%80%81%E8%A7%A3%E8%80%A6%E5%90%88-toc" style="margin-left:80px;"><a href="#2.2%E3%80%81%E8%A7%A3%E8%80%A6%E5%90%88">2.2、解耦合</a></p><p id="3%E3%80%81CPU%E7%9A%84%E6%97%B6%E9%97%B4%E5%88%86%E7%89%87%EF%BC%88CPU%E8%99%9A%E6%8B%9F%E5%8C%96%EF%BC%89-toc" style="margin-left:40px;"><a href="#3%E3%80%81CPU%E7%9A%84%E6%97%B6%E9%97%B4%E5%88%86%E7%89%87%EF%BC%88CPU%E8%99%9A%E6%8B%9F%E5%8C%96%EF%BC%89">3、CPU的时间分片（CPU虚拟化）</a></p><p id="4%E3%80%81%E8%99%9A%E6%8B%9F%E5%8C%96%E4%BD%9C%E7%94%A8-toc" style="margin-left:40px;"><a href="#4%E3%80%81%E8%99%9A%E6%8B%9F%E5%8C%96%E4%BD%9C%E7%94%A8">4、虚拟化作用</a></p><p id="5%E3%80%81%E8%99%9A%E6%8B%9F%E5%8C%96%E5%B7%A5%E4%BD%9C%E5%8E%9F%E7%90%86-toc" style="margin-left:40px;"><a href="#5%E3%80%81%E8%99%9A%E6%8B%9F%E5%8C%96%E5%B7%A5%E4%BD%9C%E5%8E%9F%E7%90%86">5、虚拟化工作原理</a></p><p id="%C2%A05.1%E3%80%81QEMU-toc" style="margin-left:80px;"><a href="#%C2%A05.1%E3%80%81QEMU">&nbsp;5.1、QEMU</a></p><p id="5.2%E3%80%81KVM-toc" style="margin-left:80px;"><a href="#5.2%E3%80%81KVM">5.2、KVM</a></p><p id="5.3%E3%80%81%E8%99%9A%E6%8B%9F%E5%8C%96%E7%B1%BB%E5%9E%8B-toc" style="margin-left:80px;"><a href="#5.3%E3%80%81%E8%99%9A%E6%8B%9F%E5%8C%96%E7%B1%BB%E5%9E%8B">5.3、虚拟化类型</a></p><p id="5.4%E3%80%81%E8%99%9A%E6%8B%9F%E5%8C%96%E7%9A%84%E5%8A%9F%E8%83%BD-toc" style="margin-left:80px;"><a href="#5.4%E3%80%81%E8%99%9A%E6%8B%9F%E5%8C%96%E7%9A%84%E5%8A%9F%E8%83%BD">5.4、虚拟化的功能</a></p><p id="%E4%BA%8C%E3%80%81Docker%20%E6%A6%82%E8%BF%B0-toc" style="margin-left:0px;"><a href="#%E4%BA%8C%E3%80%81Docker%20%E6%A6%82%E8%BF%B0">二、Docker 概述</a></p><p id="1%E3%80%81docker%E6%98%AF%E4%BB%80%E4%B9%88%EF%BC%9F-toc" style="margin-left:40px;"><a href="#1%E3%80%81docker%E6%98%AF%E4%BB%80%E4%B9%88%EF%BC%9F">1、docker是什么？</a></p><p id="2%E3%80%81Docker%E7%9A%84%E8%AE%BE%E8%AE%A1%E5%AE%97%E6%97%A8-toc" style="margin-left:40px;"><a href="#2%E3%80%81Docker%E7%9A%84%E8%AE%BE%E8%AE%A1%E5%AE%97%E6%97%A8">2、Docker的设计宗旨</a></p><p id="3%E3%80%81Docker%E7%89%B9%E7%82%B9-toc" style="margin-left:40px;"><a href="#3%E3%80%81Docker%E7%89%B9%E7%82%B9">3、Docker特点</a></p><p id="4%E3%80%81Docker%E7%9A%84%E4%BC%98%E5%8A%BF%E5%92%8C%E6%84%8F%E4%B9%89-toc" style="margin-left:40px;"><a href="#4%E3%80%81Docker%E7%9A%84%E4%BC%98%E5%8A%BF%E5%92%8C%E6%84%8F%E4%B9%89">4、Docker的优势和意义</a></p><p id="5%E3%80%81%E5%AE%B9%E5%99%A8%E4%B8%8EKVM%EF%BC%88%E8%99%9A%E6%8B%9F%E6%9C%BA%EF%BC%89%E7%9A%84%E5%8C%BA%E5%88%AB-toc" style="margin-left:40px;"><a href="#5%E3%80%81%E5%AE%B9%E5%99%A8%E4%B8%8EKVM%EF%BC%88%E8%99%9A%E6%8B%9F%E6%9C%BA%EF%BC%89%E7%9A%84%E5%8C%BA%E5%88%AB">5、容器与KVM（虚拟机）的区别</a></p><p id="5.1%E3%80%81%E9%9A%94%E7%A6%BB%E4%B8%8E%E5%85%B1%E4%BA%AB-toc" style="margin-left:80px;"><a href="#5.1%E3%80%81%E9%9A%94%E7%A6%BB%E4%B8%8E%E5%85%B1%E4%BA%AB">5.1、隔离与共享</a></p><p id="5.2%E3%80%81%E6%80%A7%E8%83%BD%E4%B8%8E%E6%8D%9F%E8%80%97-toc" style="margin-left:80px;"><a href="#5.2%E3%80%81%E6%80%A7%E8%83%BD%E4%B8%8E%E6%8D%9F%E8%80%97">5.2、性能与损耗</a></p><p id="%E4%B8%89%E3%80%81Docker%E7%9A%84%E4%BD%BF%E7%94%A8%E5%9C%BA%E6%99%AF-toc" style="margin-left:40px;"><a href="#%E4%B8%89%E3%80%81Docker%E7%9A%84%E4%BD%BF%E7%94%A8%E5%9C%BA%E6%99%AF">三、Docker的使用场景</a></p><p id="%E5%9B%9B%E3%80%81Docker%E5%BC%95%E6%93%8E%EF%BC%88Docker%20Engine%EF%BC%89-toc" style="margin-left:0px;"><a href="#%E5%9B%9B%E3%80%81Docker%E5%BC%95%E6%93%8E%EF%BC%88Docker%20Engine%EF%BC%89">四、Docker引擎（Docker Engine）</a></p><p id="%E4%BA%94%E3%80%81Docker%E5%AE%B9%E5%99%A8%E6%A6%82%E8%BF%B0-toc" style="margin-left:0px;"><a href="#%E4%BA%94%E3%80%81Docker%E5%AE%B9%E5%99%A8%E6%A6%82%E8%BF%B0">五、Docker容器概述</a></p><p id="1%E3%80%81Docker%E7%9A%84%E6%9E%B6%E6%9E%84%EF%BC%88Docker%20architecture%EF%BC%89-toc" style="margin-left:40px;"><a href="#1%E3%80%81Docker%E7%9A%84%E6%9E%B6%E6%9E%84%EF%BC%88Docker%20architecture%EF%BC%89">1、Docker的架构（Docker architecture）</a></p><p id="2%E3%80%81%E7%AE%80%E8%BF%B0Docker%E4%BD%93%E7%B3%BB%E6%9E%B6%E6%9E%84-toc" style="margin-left:40px;"><a href="#2%E3%80%81%E7%AE%80%E8%BF%B0Docker%E4%BD%93%E7%B3%BB%E6%9E%B6%E6%9E%84">2、简述Docker体系架构</a></p><p id="3%E3%80%81Docker%20%E4%B8%89%E8%A6%81%E7%B4%A0%EF%BC%88%E6%A0%B8%E5%BF%83%E7%BB%84%E4%BB%B6%EF%BC%89-toc" style="margin-left:40px;"><a href="#3%E3%80%81Docker%20%E4%B8%89%E8%A6%81%E7%B4%A0%EF%BC%88%E6%A0%B8%E5%BF%83%E7%BB%84%E4%BB%B6%EF%BC%89">3、Docker 三要素（核心组件）</a></p><p id="4%E3%80%81Docker%E8%BF%90%E8%A1%8C%E6%B5%81%E7%A8%8B-toc" style="margin-left:40px;"><a href="#4%E3%80%81Docker%E8%BF%90%E8%A1%8C%E6%B5%81%E7%A8%8B">4、Docker运行流程</a></p><p id="%C2%A05%E3%80%81namespace%20%EF%BC%88%E5%90%8D%E7%A7%B0%E7%A9%BA%E9%97%B4%EF%BC%89-toc" style="margin-left:40px;"><a href="#%C2%A05%E3%80%81namespace%20%EF%BC%88%E5%90%8D%E7%A7%B0%E7%A9%BA%E9%97%B4%EF%BC%89">&nbsp;5、namespace （名称空间）</a></p><p id="6%E3%80%81%E8%B5%84%E6%BA%90%E6%8E%A7%E5%88%B6%E2%80%94%E2%80%94cgroups-toc" style="margin-left:40px;"><a href="#6%E3%80%81%E8%B5%84%E6%BA%90%E6%8E%A7%E5%88%B6%E2%80%94%E2%80%94cgroups">6、资源控制——cgroups</a></p><p id="7%E3%80%81%E5%AE%B9%E5%99%A8%E5%B0%8F%E7%9A%84%E6%9E%B6%E6%9E%84%E4%BD%93%E7%B3%BB-toc" style="margin-left:40px;"><a href="#7%E3%80%81%E5%AE%B9%E5%99%A8%E5%B0%8F%E7%9A%84%E6%9E%B6%E6%9E%84%E4%BD%93%E7%B3%BB">7、容器小的架构体系</a></p><p id="8%E3%80%81%E5%A6%82%E4%BD%95%E6%8A%8A%E5%A4%9A%E4%B8%AA%E7%9B%AE%E5%BD%95%E6%8C%82%E8%BD%BD%E5%88%B0%E5%90%8C%E4%B8%80%E4%B8%AA%E7%9B%AE%E5%BD%95%E4%B8%8B%EF%BC%9F-toc" style="margin-left:40px;"><a href="#8%E3%80%81%E5%A6%82%E4%BD%95%E6%8A%8A%E5%A4%9A%E4%B8%AA%E7%9B%AE%E5%BD%95%E6%8C%82%E8%BD%BD%E5%88%B0%E5%90%8C%E4%B8%80%E4%B8%AA%E7%9B%AE%E5%BD%95%E4%B8%8B%EF%BC%9F">8、如何把多个目录挂载到同一个目录下？</a></p><p id="%E5%85%AD%E3%80%81%E6%80%BB%E7%BB%93-toc" style="margin-left:0px;"><a href="#%E5%85%AD%E3%80%81%E6%80%BB%E7%BB%93">六、总结</a></p><p><hr id="hr-toc"></p><h4>前言：<img alt="" height="444" src="https://img-blog.csdnimg.cn/b1dc8f61d8a64457b7f1c239b632efb8.png" width="800"></h4><p>容器是一种技术，开发人员打包开发完成的一个应用（系统）以及所需的开发环境，然后通过容器可以运行在不同的计算机上面，也不需要重新配置相关环境，不同的是每一台计算机都需要配置运行容器的容器引擎，目前市场上主流就是Docker容器引擎，不过Docker容器引擎的配置很简单，比配置应用（系统）运行的环境简单，方便太多。每台要运行应用（系统）的计算机上面配置了Docker容器引擎之后，都单独独立可以运行之前打包完成的应用（系统）。</p><p><strong>以linux而言，linux操作系统会有一个主进程pid=1派生出其他进程来控制不同服务</strong></p><pre><code>例如:

pid=2 ——&gt; python
pid=3——&gt;java
pid=4——&gt;php</code></pre><p>三个服务可能会相互影响</p><p>使用者期望将这<strong>三个不同的服务，跑在不同的运行时环境中实现相互不影响</strong>，同时不会增加服务器成本</p><ul>
  <li>延伸出——&gt;能否将这<strong>三种服务分别封装起来</strong>——&gt;<strong>KVM虚拟化技术</strong>，实现了一个操作系统模拟多个操作系统/不同的运行时环境</li>
  <li>随着技术发展——&gt;<strong>虚拟化技术开销较大</strong>(例如:只要运行一个py脚本，想要使用虚拟化方式实现，还需要安装一个操作系统，并不方便/合理)</li>
 </ul><p>——&gt;延伸出容器技术<br />虚拟化层的抽象层(用户层)剥离，使用<strong>docker engine</strong>来替代(来bin操作系统去除)，只要<strong>通过引擎</strong>就可以直接连接到宿主机操作系统中，极大减小了开销。</p><h2 id="%C2%A0%E4%B8%80%E3%80%81%E8%99%9A%E6%8B%9F%E5%8C%96">&nbsp;一、虚拟化</h2><h3 id="1%E3%80%81%E8%99%9A%E6%8B%9F%E5%8C%96%E6%A6%82%E8%BF%B0">1、虚拟化概述</h3><p>虚拟化，是指通过虚拟化技术<strong>将一台计算机虚拟为多台逻辑计算机</strong>。在一台计算机上同时运行多个逻辑计算机，每个逻辑计算机可运行不同的操作系统，并且应用程序都可以在相互独立的空间内运行而互相不影响，从而显著提高计算机的工作效率。</p><p><strong>简单来说</strong></p><p><strong>虚拟化</strong>：就是将应用程序和系统内核资源进行<strong>解耦</strong>，以<strong>操作系统级别</strong>进行隔离，目的是<strong>提高资源利用率</strong></p><p>虚拟化使用软件的方法重新定义划分 IT 资源，可以实现 IT 资源的动态分配、灵活调度、跨域共享，提高 IT 资源利用率，使 IT 资源能够真正成为社会基础设施，服务于各行各业中灵活多变的应用需求。</p><pre><code>在一个操作系统中（win10）模拟多个操作系统（centos、win10、suse），
同时每个操作系统可以跑不同的服务（nginx+tomcat）,从而实现一台宿主机搭建一个集群（从整体）。
通过软件/应用程序的方式，来实现物理硬件的功能。
例如ensp,以软件形式实现物理设备的功能（二层交换机、路由器、三层交换机等）。
</code></pre><h3 id="2%E3%80%81%E8%80%A6%E5%90%88%E4%B8%8E%E8%A7%A3%E8%80%A6%E5%90%88">2、耦合与解耦合</h3><p>耦合性是<strong>程序结构中各个模块之间相互关联的度量</strong>。它取决于各个模块之间的接口的复杂程度、调用模块的方式以及哪些信息通过接口。</p><pre><code>耦合是项目模块之间的关联度高及相互依赖程度高，
也就是说我们在后期项目修改时，如果耦合度高的话，这样会牵一发而动全身，增加了相应的维护成本
相反，解耦合就是要降低这种模块之间的相互依赖程度，降低维护成本与复杂度。</code></pre><h4 id="2.1%E3%80%81%E8%80%A6%E5%90%88">2.1、耦合</h4><p><strong>耦合</strong>是指两个或两个以上的体系或两种运动形式间通过相互作用而彼此影响以至联合起来的现象。</p><p>对象之间的耦合度就是对象之间的依赖性。</p><p>对象之间的耦合越高，维护成本越高</p><h4 id="2.2%E3%80%81%E8%A7%A3%E8%80%A6%E5%90%88">2.2、解耦合</h4><p>字面意思就是解除耦合关系。</p><p>在软件工程中，降低耦合度即可以理解为解耦，模块间有依赖关系必然存在耦合，理论上的绝对零耦合是做不到的，但可以通过一些现有的方法将耦合度降至最低。</p><h3 id="3%E3%80%81CPU%E7%9A%84%E6%97%B6%E9%97%B4%E5%88%86%E7%89%87%EF%BC%88CPU%E8%99%9A%E6%8B%9F%E5%8C%96%EF%BC%89">3、CPU的时间分片（CPU虚拟化）</h3><p><img alt="" height="495" src="https://img-blog.csdnimg.cn/3553011e721d494fbb55be1656c736eb.png" width="776"></p><pre><code>正常每个任务以轮询的方式去处理，这个时候一个CPU一个整体。
以下是针对的CPU单位时间内的一个资源。按时间划分，1秒划分成10个0.1秒，
每个0.1秒可以全力处理10单位的任务。在1秒内，都在全力工作。

cpu 1s全力运转的性能——》逻辑分割成分成了10份，可以理解为在单位时间内可以处理10个任务，
每一个0.1s cpu是满的。原先分片前100M以下的任务一次只可以处理1个，现在100M的任务一次可以处理10个。这就是时间分片的一个概念。</code></pre><h3 id="4%E3%80%81%E8%99%9A%E6%8B%9F%E5%8C%96%E4%BD%9C%E7%94%A8">4、虚拟化作用</h3><p><strong>缓解/解决了资源利用率的问题</strong></p><p>物理硬件的性能就会比虚拟化的性能高,在极度吃资源的情况下，例如mysql高并发这种，就不适合用虚拟化。</p><h3 id="5%E3%80%81%E8%99%9A%E6%8B%9F%E5%8C%96%E5%B7%A5%E4%BD%9C%E5%8E%9F%E7%90%86">5、虚拟化工作原理</h3><p><img alt="" height="680" src="https://img-blog.csdnimg.cn/5fbefdc225c04be18408de2fd98ba51b.png" width="1121"></p><pre><code>虚拟机管理器功能：调用资源

两大核心组件：QEMU、KVM</code></pre><h4 id="%C2%A05.1%E3%80%81QEMU">&nbsp;5.1、QEMU</h4><ol>
  <li>QEMU是<strong>I/O控制的模块</strong>，可以理解为队列，核心目的是调用资源内核中的资源，需要把KVM逻辑分割出来的资源运输给QEMU，再给虚拟机。</li>
  <li>QEMU它并不是直接调用，<strong>而是用I/O方式调用，</strong>QEMU把资源调用来的过程借用ioctl，QEMU借助libvirt这个工具调用ioctl，再通过接口，给虚拟机应用程序。</li>
 </ol><h4 id="5.2%E3%80%81KVM">5.2、KVM</h4><ol>
  <li>用来<strong>逻辑分割物理资源</strong>，<strong>抽象化为虚拟化资源</strong>，根据VMM里的配置，会逻辑分割出多少G，给应用程序，去进行虚拟化。</li>
  <li>只接受来自QEMU的请求指令。对于应用程序直接过来的敏感指令会拦截，然后通过接口发给QEMU，让QEMU判断是否需要执行，可以的话，再下来，不可以的话，打回去，不执行该敏感指令。</li>
 </ol><pre><code>对于workstation而言——》硬件辅助虚拟化，表现形式在处理器里面有一个虚拟化引擎，
可以勾取硬件辅助虚拟化，看到虚拟接口/dev/kvm，可以加强辅助调用，
在应用程序需要频繁调用的时候，需要开启。比如openstack。</code></pre><h4 id="5.3%E3%80%81%E8%99%9A%E6%8B%9F%E5%8C%96%E7%B1%BB%E5%9E%8B">5.3、虚拟化类型</h4><p><strong>全虚拟化</strong>：将物理硬件资源全部通过软件的方式抽象化，最后进行调用</p><p><strong>半虚拟化</strong>：需要修改操作系统</p><p><strong>直通</strong>:直接使用物理硬件资源（需要支持，还不完善)</p><pre><code>全虚拟化：KVM——》产品vmware—ce

半虚拟化：EXSI——》workststion vsphere</code></pre><h4 id="5.4%E3%80%81%E8%99%9A%E6%8B%9F%E5%8C%96%E7%9A%84%E5%8A%9F%E8%83%BD">5.4、虚拟化的功能</h4><p>在一个操作系统内，模拟多个操作系统</p><p>以软件的方式模拟物理设备的功能</p><h2 id="%E4%BA%8C%E3%80%81Docker%20%E6%A6%82%E8%BF%B0">二、Docker 概述</h2><p>云计算涌现出很多改变传统IT架构和运维方式的新技术，比如虚拟机、容器、微服务、Serverless（无服务），无论这些技术应用在哪些场景，降低成本、提升效率是云服务永恒的主题。</p><pre><code>容器基础概念—&gt;六大名称空间
名称空间：以不同空间划分不同资源</code></pre><h3 id="1%E3%80%81docker%E6%98%AF%E4%BB%80%E4%B9%88%EF%BC%9F">1、docker是什么？</h3><p>Docker 是一个开源的应用容器引擎，基于 go 语言开发并遵循了 apache2.0 协议开源。<br />Docker 是在 Linux 容器里运行的开源工具，是一种轻量级的虚拟机。<br />Docker 的容器技术可以在一台主机上轻松为任何应用创建一个轻量级的、可移植的、自给自足的容器。</p><p>是一种轻量级的“虚拟机”，docker是一个用于开发，<strong>交付和运行应用程序的开放平台</strong>。</p><p>在Linux容器里运行应用的开源工具—》<strong>容器引擎</strong>，让开发者可以打包大量的应用以及依赖包到一个可以值得镜像中，然后发布到任何流行的Linux或者window机器中。</p><pre><code>docker的logo设计为蓝色鲸鱼，拖着许多集装箱。
鲸鱼可以作为宿主机，集装箱可理解为相互隔离的容器，每个集装箱中都包含自己的应用程序。</code></pre><h3 id="2%E3%80%81Docker%E7%9A%84%E8%AE%BE%E8%AE%A1%E5%AE%97%E6%97%A8">2、Docker的设计宗旨</h3><p>build，ship and run any App，Anywhere 即 通过对应用组件的封装、发布、部署、运行等生命期的管理，达到应用组件级别的“<strong>一次封装，到处运行</strong>”的目的。这里的组件，既可以是一个应用，也可以是一套服务，甚至是一个完整的操作系统。</p><h3 id="3%E3%80%81Docker%E7%89%B9%E7%82%B9">3、Docker特点</h3><p>容器化越来越受欢迎，因为容器是：</p><p><strong>灵活</strong>：即使是最复杂的应用也可以集装箱化。</p><p><strong>轻量级</strong>：容器利用并共享主机内核。</p><p><strong>可互换</strong>：可以即时部署更新和升级。</p><p><strong>便携式</strong>：可以在本地构建，部署到云，并在任何地方运行。</p><p><strong>可扩展</strong>：可以增加并白动分发容器副本。</p><p><strong>可堆叠</strong>：可以垂直和即时堆叠服务。</p><p>容器是在linux上本机运行，并与其他容器<strong>共享主机的内核</strong>，它运行的是一个<strong>独立的进程</strong>，不占用其他任何可执行文件的内存，非常轻量。</p><p>虚拟机运行的是一个完整的操作系统，通过虚拟机管理程序对主机资源进行虚拟访问，相比之下需要的资源更多。</p><h3 id="4%E3%80%81Docker%E7%9A%84%E4%BC%98%E5%8A%BF%E5%92%8C%E6%84%8F%E4%B9%89">4、Docker的优势和意义</h3><p><img alt="" height="495" src="https://img-blog.csdnimg.cn/63f7b84878f946b981d1f6e691321913.png" width="518"></p><p><strong>把容器化技术做成了标准化平台</strong></p><p>docker引擎统一了基础设施环境——docker环境<br />docker引擎统一了程序打包（装箱) 方式——docker镜像（把引擎放在镜像中，带着镜像到处跑）<br />docker引擎统一了程序部署（运行） 方式——docke容器（利用引擎把这个镜像再去运行为之前的相同的一模一样的容器了）</p><pre><code>镜像——》封装的一个时刻的服务/应用状态
容器——》应用跑起来的状态（正常提供服务的状态 - 运行时
有镜像才能有容器

实现了一次构建，多次、多处使用。</code></pre><h3 id="5%E3%80%81%E5%AE%B9%E5%99%A8%E4%B8%8EKVM%EF%BC%88%E8%99%9A%E6%8B%9F%E6%9C%BA%EF%BC%89%E7%9A%84%E5%8C%BA%E5%88%AB">5、容器与KVM（虚拟机）的区别</h3><h4 id="5.1%E3%80%81%E9%9A%94%E7%A6%BB%E4%B8%8E%E5%85%B1%E4%BA%AB">5.1、隔离与共享</h4><p>虚拟机通过添加Hypervisor层（虚拟化中间层），虚拟出网卡、内存、CPU等虚拟硬件，再在其上建立虚拟机，每个虚拟机都有自己的系统内核。而Docker容器则是通过隔离（namesapce）的方式，将文件系统、进程、设备、网络等资源进行隔离，再对权限、CPU资源等进行控制（cgroup），最终让容器之间互不影响，容器无法影响宿主机。</p><p><strong>容器与宿主机共享内核、文件系统、硬件等资源。</strong></p><h4 id="5.2%E3%80%81%E6%80%A7%E8%83%BD%E4%B8%8E%E6%8D%9F%E8%80%97">5.2、性能与损耗</h4><ul>
  <li>与虚拟机相比，容器资源损耗要少。</li>
  <li>同样的宿主机下，能够建立容器的数量要比虚拟机多</li>
  <li>但是，虚拟机的安全性要比容器稍好，要从虚拟机攻破到宿主机或其他虚拟机，需要先攻破 Hypervisor层，这是极其困难的</li>
  <li>而docker容器与宿主机共享内核、文件系统等资源，更有可能对其他容器、宿主机产生影响。</li>
 </ul><table border="1" cellpadding="1" cellspacing="1" style="width:600px;">
  <tbody>
   <tr>
    <th style="text-align:center;">不同点</th>
    <th style="text-align:center;">容器</th>
    <th style="text-align:center;">虚拟机</th>
   </tr>
   <tr>
    <td style="text-align:center;">启动速度</td>
    <td style="text-align:center;">快，几秒钟</td>
    <td style="text-align:center;">慢，几分钟</td>
   </tr>
   <tr>
    <td style="text-align:center;">运行性能</td>
    <td style="text-align:center;">接近原生（直接在内核中运行）</td>
    <td style="text-align:center;">运行于Hypervisor上，50%左右损失</td>
   </tr>
   <tr>
    <td style="text-align:center;">磁盘占用</td>
    <td style="text-align:center;">小，甚至几十KB（根据镜像层的情况）</td>
    <td style="text-align:center;">非常大，上GB</td>
   </tr>
   <tr>
    <td style="text-align:center;">并发性</td>
    <td style="text-align:center;">一台宿主机可以启动成百上千个容器</td>
    <td style="text-align:center;">最多几十个虚拟机</td>
   </tr>
   <tr>
    <td style="text-align:center;">隔离性</td>
    <td style="text-align:center;">进程级别</td>
    <td style="text-align:center;">资源隔离/限制</td>
   </tr>
   <tr>
    <td style="text-align:center;">磁盘占用</td>
    <td style="text-align:center;">小，甚至几十KB（根据镜像层的情况）</td>
    <td style="text-align:center;">非常大，上GB</td>
   </tr>
   <tr>
    <td style="text-align:center;">并发性</td>
    <td style="text-align:center;">一台宿主机可以启动成百上千个容器</td>
    <td style="text-align:center;">最多几十个虚拟机</td>
   </tr>
   <tr>
    <td style="text-align:center;">隔离性</td>
    <td style="text-align:center;">进程级别</td>
    <td style="text-align:center;">资源隔离/限制</td>
   </tr>
  </tbody>
 </table><h3 id="%E4%B8%89%E3%80%81Docker%E7%9A%84%E4%BD%BF%E7%94%A8%E5%9C%BA%E6%99%AF">三、Docker的使用场景</h3><p><img alt="" height="445" src="https://img-blog.csdnimg.cn/6e2fb045b7514a6a9bf11d90201700dc.png" width="795"></p><pre><code>打包应用程序部署简单

可脱离底层硬件任意迁移（实现了应用的隔离，将应用拆分并进行解耦）
例如： 需要把服务器从腾讯云迁移到阿里云，如果采用的是 Docker 容器技术
整个迁移的过程只需要在新的服务器上启动我们需要的容器就可以了。

适合做微服务的部署
提供PASS产品（平台即服务）{OpenStack的云主机类似于阿里云的ECS，
属于IAAS、Docker(K8S)属于PAAS}

适合持续集成和持续交付（CI/CD）:开发到测试发布
</code></pre><h2 id="%E5%9B%9B%E3%80%81Docker%E5%BC%95%E6%93%8E%EF%BC%88Docker%20Engine%EF%BC%89">四、Docker引擎（Docker Engine）</h2><p>&nbsp;Docker Engine是具有以下主要组件的**客户端-服务器（C/S架构）**应用程序:</p><p><strong>server端</strong>：服务器是一种长期运行的程序，称为守护程序进程( dockerd命令）。</p><p><strong>client端</strong>：REST API，它指定程序可以用来与守护程序进行通信并指示其操作的接口。</p><p>命令行界面(cLI）客户端（(docker命令）。</p><h2 id="%E2%80%8B%E7%BC%96%E8%BE%91"><img alt="" height="583" src="https://img-blog.csdnimg.cn/eac99008302b40d9b04d2503cd313256.png" width="864"></h2><h2 id="%E4%BA%94%E3%80%81Docker%E5%AE%B9%E5%99%A8%E6%A6%82%E8%BF%B0">五、Docker容器概述</h2><h3 id="1%E3%80%81Docker%E7%9A%84%E6%9E%B6%E6%9E%84%EF%BC%88Docker%20architecture%EF%BC%89">1、Docker的架构（Docker architecture）</h3><p>Docker使用<strong>客户端-服务端（C/S）架构</strong>。Docker客户端与Docker守护进程进行对话，该守护进程完成了构建，运行和分发Docker容器的繁重工作。</p><p>Docker区别于传统的虚拟化，不需要虚拟硬件资源，直接使用容器引擎，所以速度快。</p><p><strong>Docker daemon:守护进程</strong></p><p><strong>Docker守护程序</strong>（dockerd）侦听Docker API请求并管理Docker对象。例如图像、容器、网络和卷，守护程序还可以与其他守护程序通信以管理Docker服务。</p><h3 id="2%E3%80%81%E7%AE%80%E8%BF%B0Docker%E4%BD%93%E7%B3%BB%E6%9E%B6%E6%9E%84">2、简述Docker体系架构</h3><ul>
  <li><strong>Docker客户端 - Docker</strong></li>
 </ul><p>docker客户端则扮演着docker服务端的远程控制器，可以用来控制docker的服务端进程。</p><ul>
  <li><strong>Docker服务端-Docker Daemon资源限制</strong></li>
 </ul><p>docker服务端是一个服务进程，管理着所有的容器。</p><ul>
  <li><strong>Docker镜像一Imagefont&gt;</strong></li>
 </ul><p>Docker的镜像是创建容器的基础，类似虚拟机的快照，可以理解为一个面向Docker容器引擎的只读模板。通过镜像启动一个容器，一个镜像是一个可执行的包,其中包括运行应用程序所需要的所有内容包含代码。运行时间，库，环境变量，和配置文件</p><ul>
  <li><strong>Docker容器-Docker Container</strong></li>
 </ul><p>Docker的容器是从镜像创建的运行实例，它可以被启动、停止和删除。所创建的每一个容器都是相互隔离、互不可见，以保证平台的安全性。</p><ul>
  <li><strong>Docker镜像仓库-- Registryfont&gt;</strong></li>
 </ul><p>Docker仓库是用来集中保存镜像的地方,当创建了自己的镜像之后，可以使用push命令将它上传到公有仓库(Public)或者私有仓库(Private、常用）。当下次要在另外一台机器上使用这个镜像时，只需从仓库获取。</p><p>Docker的镜像、容器、日志等内容全部都默认存储在<strong><code>/var/lib/docker</code></strong>目录下。</p><h3 id="3%E3%80%81Docker%20%E4%B8%89%E8%A6%81%E7%B4%A0%EF%BC%88%E6%A0%B8%E5%BF%83%E7%BB%84%E4%BB%B6%EF%BC%89">3、Docker 三要素（核心组件）</h3><p>Docker images:镜像：统一的封装方式——》模板</p><p>Docker container:容器：统一的运行时环境 ——》基于镜像，运行状态/运行时状态</p><p>Docker registry:镜像仓库：放置镜像的仓库——》存放镜像模板</p><p>存储镜像的地方，默认在公共的 Docker Hub上查找，可以搞个人仓库。</p><p><strong>仓库大类：①公共仓库—》docker hub ②私有仓库registry harbor</strong></p><h3 id="4%E3%80%81Docker%E8%BF%90%E8%A1%8C%E6%B5%81%E7%A8%8B">4、Docker运行流程</h3><p><img alt="" height="529" src="https://img-blog.csdnimg.cn/1bbd5d9450d147999d10f7a24883381f.png" width="1001"></p><pre><code>工作流程：

客户端发起各种各样的命令，给与主机
build：制作镜像（image）
pull：拉取镜像（拉倒本地去使用）
run：运行容器的（docker）

主机会调用镜像，如果有镜像直接用，运行为容器
如果镜像里没有会到registry公共仓库去拉去镜像，拉到本地后再运行为容器</code></pre><h3 id="%C2%A05%E3%80%81namespace%20%EF%BC%88%E5%90%8D%E7%A7%B0%E7%A9%BA%E9%97%B4%EF%BC%89">&nbsp;5、namespace （名称空间）</h3><p><strong>namespace资源隔离——用容器技术封装</strong></p><p><img alt="" height="373" src="https://img-blog.csdnimg.cn/611208113c0c4e0c9db26a1d60e5a1b7.png" width="845"></p><table border="1" cellpadding="1" cellspacing="1" style="width:600px;">
  <tbody>
   <tr>
    <th style="text-align:center;">mount</th>
    <th style="text-align:center;">文件系统，挂载点——&gt;一个文件系统内，不能重复挂载一个指定目录</th>
   </tr>
   <tr>
    <td style="text-align:center;">user</td>
    <td style="text-align:center;">操作进程的用户和用户组</td>
   </tr>
   <tr>
    <td style="text-align:center;">pid</td>
    <td style="text-align:center;">进程编号</td>
   </tr>
   <tr>
    <td style="text-align:center;">uts</td>
    <td style="text-align:center;">主机名和主机域 （同一个环境里不能又叫node1又叫node2）</td>
   </tr>
   <tr>
    <td style="text-align:center;">ipc</td>
    <td style="text-align:center;">信号量、消息队列、共享内存(不同的应用调用内存资源的时候应该使用不同的内存空间)</td>
   </tr>
   <tr>
    <td style="text-align:center;">net（网络资源）</td>
    <td style="text-align:center;">网络设备、网络协议栈（在同一个网络名称空间中的网络规则）、端口等</td>
   </tr>
  </tbody>
 </table><h3 id="6%E3%80%81%E8%B5%84%E6%BA%90%E6%8E%A7%E5%88%B6%E2%80%94%E2%80%94cgroups">6、资源控制——cgroups</h3><p><strong>六种名称空间是由cgroups管理的</strong><br />最后一种centos的cgroups管理版本是3.8版本，3.6和3.5已经不用了</p><p>cgroups 管理linux内核态中资源管理的模块</p><p>cgroups 管理一些系统资源</p><p>不是docker原生的。</p><pre><code>【CPU为什么能够划分时间片，就是通过cgroups去划分管理的】</code></pre><p>Linux上的Docker引擎还依赖于另一种称为控制组 （cgroups）的技术。cgroup将应用程序限制为一组特定的资源。控制组允许Docker Engine将可用的硬件资源共享给容器，并有选择地实施限制和约束。例如，您可以限制特定容器可用的内存。</p><h3 id="7%E3%80%81%E5%AE%B9%E5%99%A8%E5%B0%8F%E7%9A%84%E6%9E%B6%E6%9E%84%E4%BD%93%E7%B3%BB">7、容器小的架构体系</h3><p><img alt="" src="https://img-blog.csdnimg.cn/img_convert/d9c9ab404a035ead7515317e346a2101.png"></p><h3 id="8%E3%80%81%E5%A6%82%E4%BD%95%E6%8A%8A%E5%A4%9A%E4%B8%AA%E7%9B%AE%E5%BD%95%E6%8C%82%E8%BD%BD%E5%88%B0%E5%90%8C%E4%B8%80%E4%B8%AA%E7%9B%AE%E5%BD%95%E4%B8%8B%EF%BC%9F">8、如何把多个目录挂载到同一个目录下？</h3><p>（存储引擎)overlay2（现在使用） 和 （存储引擎) aufs（早期使用）叠加式文件系统</p><p><img alt="image-20220109221559427" src="https://img-blog.csdnimg.cn/img_convert/29f8906f9dad0e34d2e4638ac2eda217.png"></p><pre><code>docker引擎统—了程序部署(运行)方式-docker容器——&gt;基于镜像——&gt;运行为容器(可运行的环境)

实现了一次构建，多次、多处使用</code></pre><h2 id="%E5%85%AD%E3%80%81%E6%80%BB%E7%BB%93">六、总结</h2><p>容器的概念：容器是一种数据类型，是序列，存储大量的数据，学习容器的意义:容器可以改变变量只能存储单个数据的缺陷</p></div><p>原文链接：https://blog.csdn.net/weixin_56270746/article/details/125751186</p>