Docker知识点总结

一：Docker 简介

一、Docker 是什么？

1. Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）。几乎没有性能开销，可以很容易地在机器和数据中心中运行。最重要的是，他们不依赖于任何语言、框架包括系统。

2. Docker 是基于Go语言实现的云开源项目，诞生于2013年初，最初是dotCloud公司发起。由镜像(Image)、容器(Container)、仓库(Repository) 三大核心组成。

3. Docker 通过对应用组件的封装、分发、部署、运行等生命周期的管理，达到应用组件级别的“一次封装，到处运行”。这里应用组件，即可以是Web应用，也可以是一套数据库服务，甚至是一个操作系统或编译器。

二、为什么要使用 Docker？

1. Docker 是一个用于开发，交付和运行应用程序的开放平台。Docker 使您能够将应用程序与基础架构分开，从而可以快速交付软件。借助 Docker，您可以与管理应用程序相同的方式来管理基础架构。通过利用 Docker 的方法来快速交付，测试和部署代码，您可以大大减少编写代码和在生产环境中运行代码之间的延迟。

2. 更快速的交付和部署(使用docker，开发人员可以用镜像来快速构建一套标准的开发环境;开发完成之后，测试和运维人员可以直接使用相同环境来部署代码)。

3. 响应式部署和扩展(docker容器几乎可以在任意平台上运行，包括物理机、虚拟机、公有云、私有云、个人电脑、服务器等。可以在不同的平台轻松地迁移应用)。

4. 更简单的更新管理(使用Dockerfile，只需要修改小小的配置，就可以替代以往大量的更新工作)。

1. 与传统的虚拟机对比

2. 传统开发流程

3. Docker开发流程

三、Docker 架构

1. Docker 核心三要素

1. 镜像（Image）：用于创建 Docker 容器的模板，相当于一个 root 文件系统。镜像内部是一个精简的操作系统和应用运行所需要的文件以及所有依赖（镜像不包含内核，容器都是共享所在Docker主机的内核），比如官方镜像 ubuntu:16.04 就包含了完整的一套 Ubuntu16.04 最小系统的 root 文件系统。

2. 容器（Container）：容器是镜像的运行时实例，可以从单个镜像启动一个或多个容器。

3. 仓库（Repository）：用于存放镜像，可以理解为代码控制中的代码仓库。一个 Docker Registry 中可以包含多个仓库（Repository）；每个仓库可以包含多个标签（Tag）；每个标签对应一个镜像。

2. 核心架构

1. Docker 使用客户端-服务器 (C/S) 架构模式，使用远程API来管理和创建Docker容器。

2. Docker 容器通过 Docker 镜像来创建。

3. 运行原理

1. 命令行工具或CLI在被称为用户空间的内存中运行，就像是在操作系统上运行的其他程序。运行 Docker 可以认为是在用户空间运行着两个程序：一个是 Docker 守护进程，另一个是 DockerCLI，DockerCLI 是与用户交互的 Docker 程序。上图也显示了三个运行着的容器，每个都是以 Docker 守护程序的子进程运行，封装在容器中。在容器中运行的程序只能访问该容器内部的内存空间和资源（除非特别规定可以访问容器外部资源）。

2. Docker 可以执行、复制和轻松的分发容器，Docker 通过一种打包和分发的软件完成传统容器的封装，这个用来充当容器（Container）分发角色的组件被称为镜像（Image）。

四、安装部署（Centos7）

1. 查看内核版本（高于3.10）

1 [root@docker ~]# uname -r
2 3.10.0-327.el7.x86_64  # 必须是3.10版本以上

2. 卸载旧版本 Docker

1 [root@docker ~]# yum remove docker  docker-common docker-selinux docker-engine
2 Loaded plugins: fastestmirror
3 No Match for argument: docker
4 No Match for argument: docker-common
5 No Match for argument: docker-selinux
6 No Match for argument: docker-engine
7 No Packages marked for removal

3. 安装需要的软件包

 1 [root@localhost ~]# yum install -y yum-utils device-mapper-persistent-data lvm2
 2 Loaded plugins：fastestmirror
 3 Loading mirror speeds from cached hostfile
 4  * base: centos.ustc.edu.cn
 5  * extras: mirrors.aliyun.com
 6  * updates: mirrors.cn99.com
 7 软件包 device-mapper-persistent-data-0.7.3-3.el7.x86_64 已安装并且是最新版本
 8 软件包 7:lvm2-2.02.180-10.el7_6.8.x86_64 已安装并且是最新版本
 9 正在解决依赖关系
10 --> 正在检查事务
11 ---> 软件包 yum-utils.noarch.0.1.1.31-50.el7 将被 安装
12 --> 正在处理依赖关系 python-kitchen，它被软件包 yum-utils-1.1.31-50.el7.noarch

4. 设置 yum 源

 1 ### 中央仓库
 2 [root@localhost ~]# yum-config-manager --add-repo http://download.docker.com/docker-ce/linux/centos/docker-ce.repo
 3 Loaded plugins: fastestmirror
 4 adding repo from: http://download.docker.com/docker-ce/linux/centos/docker-ce.repo
 5 grabbing file http://download.docker.com/docker-ce/linux/centos/docker-ce.repo to /etc/yum.repos.d/docker-ce.repo
 6 repo saved to /etc/yum.repos.d/docker-ce.repo
 7 
 8 ### 阿里云
 9 [root@localhost ~]# yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
10 Loaded plugins: fastestmirror
11 adding repo from: http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
12 grabbing file http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo to /etc/yum.repos.d/docker-ce.repo
13 repo saved to /etc/yum.repos.d/docker-ce.repo

5. 安装 Docker

 1 ### 查看仓库中 Docker的版本
 2 [root@docker ~]# yum list docker-ce --showduplicates | sort -r
 3  * updates: mirrors.nju.edu.cn
 4 Loading mirror speeds from cached hostfile
 5 Loaded plugins: fastestmirror
 6 Installed Packages
 7  * extras: mirrors.nju.edu.cn
 8 docker-ce.x86_64            3:19.03.9-3.el7                    docker-ce-stable 
 9 docker-ce.x86_64            3:19.03.8-3.el7                    docker-ce-stable 
10 docker-ce.x86_64            3:19.03.7-3.el7                    docker-ce-stable 
30 docker-ce.x86_64            18.06.3.ce-3.el7                   docker-ce-stable 
31 docker-ce.x86_64            18.06.2.ce-3.el7                   docker-ce-stable 
32 docker-ce.x86_64            18.06.1.ce-3.el7                   docker-ce-stable 
33 docker-ce.x86_64            18.06.0.ce-3.el7                   docker-ce-stable 
34 docker-ce.x86_64            18.03.1.ce-1.el7.centos            docker-ce-stable 
35 docker-ce.x86_64            18.03.0.ce-1.el7.centos            docker-ce-stable 
36 docker-ce.x86_64            17.12.1.ce-1.el7.centos            docker-ce-stable 
37 docker-ce.x86_64            17.12.0.ce-1.el7.centos            docker-ce-stable 
43 docker-ce.x86_64            17.03.3.ce-1.el7                   docker-ce-stable 
44 docker-ce.x86_64            17.03.2.ce-1.el7.centos            docker-ce-stable 
45 docker-ce.x86_64            17.03.1.ce-1.el7.centos            docker-ce-stable 
46 docker-ce.x86_64            17.03.0.ce-1.el7.centos            docker-ce-stable 
47 
48 ### 安装最新版本
49 [root@localhost ~]# yum install -y docker-ce
50 Loaded plugins: fastestmirror
51 Loading mirror speeds from cached hostfile
52  * base: mirrors.nju.edu.cn
53  * extras: mirrors.nju.edu.cn
54  * updates: mirrors.nju.edu.cn
55 Resolving Dependencies
56 --> Running transaction check
57 ---> Package docker-ce.x86_64 3:19.03.10-3.el7 will be installed
58 --> Processing Dependency: container-selinux >= 2:2.74 for package: 3:docker-ce-19.03.10-3.el7.x86_64
59 --> Processing Dependency: containerd.io >= 1.2.2-3 for package: 3:docker-ce-19.03.10-3.el7.x86_64
60 --> Processing Dependency: libseccomp >= 2.3 for package: 3:docker-ce-19.03.10-3.el7.x86_64
61 --> Processing Dependency: docker-ce-cli for package: 3:docker-ce-19.03.10-3.el7.x86_64
62 --> Processing Dependency: libcgroup for package: 3:docker-ce-19.03.10-3.el7.x86_64
63 --> Processing Dependency: libseccomp.so.2()(64bit) for package: 3:docker-ce-19.03.10-3.el7.x86_64
64 
65 ### 安装特定版本
66 yum install -y docker-ce-版本 docker-ce-selinux-版本 docker-ce-cli-版本 containerd.io

6. 启动docker

1 [root@localhost ~]# systemctl start docker
2 [root@localhost ~]# systemctl enable docker
3 Created symlink from /etc/systemd/system/multi-user.target.wants/docker.service to /usr/lib/systemd/system/docker.service.

7. 配置阿里云镜像加速

1. 获取自己的镜像加速地址：点击“创建我的容器镜像”

2. 编写配置文件

1 [root@docker ~]# mkdir -p /etc/docker/daemon.json
2 [root@docker ~]# vi /etc/docker/daemon.json
4 {
5   "registry-mirrors": ["https://78ssvya7.mirror.aliyuncs.com"]
6 }
8 [root@docker ~]# systemctl daemon-reload
9 [root@docker ~]# systemctl restart docker

二：Docker 核心操作

一、Docker 镜像

1. 简介：镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件。它包含运行某个软件所需的所有内容，包括代码、运行时、库、环境变量和配置文件。

2. 镜像分层

1. 原理：Docker 镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS（联合文件系统）：是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下。Union 文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。

2. 特性

1. 一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录。

2. Docker镜像都是只读的。当容器启动时，一个新的可写层被加载到镜像的顶部。

3. 共享资源。一个基础镜像可以实例多个容器。

3. 多架构镜像（Multi-architecture Image）

1. 原理：在拉取镜像的时候，Docker 客户端会调用 Docker 镜像仓库服务的 API 完成拉取。如果该镜像有 Manifest 列表，则 Docker 客户端会找到当前主机架构对应的 Manifest 并解析出组成该镜像的镜像层加密ID，然后从镜像仓库中拉取每个镜像层。

2. 作用：是为了解决镜像支持不同架构（Linux、Windows、ARM等）的问题。为了实现这个特性，镜像仓库服务API支持两种重要的结构：Manifest列表和Manifest。Manifest列表是指某个镜像标签支持的架构列表，其支持的每种架构都有自己的Manifest定义，其中列举了镜像的构成。如下图所示，图中左侧是Manifest列表，其中包含了该镜像支持的每种架构。Manifest列表的每一项都有一个箭头，指向具体的Manifest，其中包含了镜像配置和镜像层数据。

4. 常用操作

二、Docker 容器

1. 容器是镜像的运行时实例，可以从单个镜像启动一个或多个容器。

2. 相对于虚拟机，容器较轻量级，而且容器启动非常快————与虚拟机运行在完整的操作系统之上相比，容器会共享其所在主机的操作系统/内核（一个很简单是证明方法就是在容器内部查看下进程，在容器所在主机的操作系统上也能找到容器内部运行的进程（由于容器拥有隔离的PID，所以进程号会不同，但是进程确是相同的））。

3. Docker在创建容器的时候会为每个容器分配一个唯一的标识符，也会分配一个人性化的名称（如果用户没有指定名称的话）。

4. Docker容器有四种状态：运行中（Up）、暂停中（Paused）、已退出（Exited）、重新启动中（一种临时状态），状态转移图如下：

5. 常用操作

6. 重启策略（--restart 重启策略）

1. always：除非容器被明确停止，否则会一直尝试重启处于停止状态的容器。当Docker daemon重启的时候，停止的容器也会被重启。

2. unless-stopped：unless-stopped 和 always 最大区别的就是使用 unless-stopped 策略并处于已退出状态的容器，不会在Docker daemon重启的时候被重启。

3. on-failure：退出容器并且返回值不是0的时候重启容器，就算容器处于已退出状态，在Docker daemon重启的时候，容器也会重启。

三、Docker 网络

1. 网络容器模型：Closed容器、Bridged容器（默认）、Joined容器、Open容器，所有的Docker容器都要符合这四种模型中的一种。这些模型定义了一个容器如何与其他的本地容器、主机网络进行通信。

2. Closed 容器：不允许任何的网络流量，运行在这种容器中的进程只能访问本地回环接口。

1 # 可以看到，Closed容器只有一个回环接口
2 [root@server ~]# docker run --name centos centos:latest ip a
3 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
4     link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
5     inet 127.0.0.1/8 scope host lo
6        valid_lft forever preferred_lft forever

3. Bridged 容器：默认的网络容器模型，有两个接口，一个是本地回环接口，另一个接口通过网桥连接到主机网络。可以通过主机网络访问任何主机网络能访问的外部网络。

 1 # 一个本地回环接口，一个桥接到主机网络的接口
 2 [root@server ~]#  docker run --network bridge centos:latest ip a;
 3 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
 4     link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
 5     inet 127.0.0.1/8 scope host lo
 6        valid_lft forever preferred_lft forever
 7 255: eth0@if256: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
 8     link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff
 9     inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
10        valid_lft forever preferred_lft forever
11 [root@server ~]#  ping -c 2 www.baidu.com
12 PING www.a.shifen.com (180.101.49.12) 56(84) bytes of data.
13 64 bytes from 180.101.49.12 (180.101.49.12): icmp_seq=1 ttl=50 time=29.0 ms
14 64 bytes from 180.101.49.12 (180.101.49.12): icmp_seq=2 ttl=50 time=28.4 ms

4. Joined 容器：所有容器共享一个网络栈，容器之间没有任何网络隔离。Joined容器通过将某一个容器接口的访问权限提供给另外一个新的容器来构建。

 1 # 创建一个closed容器，看下其内部网络状态，可以看到容器内部监听的是39439端口
 2 [root@server ~]# docker run -d --name join-base-container --network none centos:latest
 3 e2907c7a889d209734f63309a5351687ac2761489e129cd6a7d6a392234a3cde
 4 [root@server ~]# docker exec join-base-container netstat -al
 5 Active Internet connections (servers and established)
 6 Proto Recv-Q Send-Q Local Address           Foreign Address         State       
 7 tcp        0      0 0.0.0.0:39439           0.0.0.0:*               LISTEN      
 8 Active UNIX domain sockets (servers and established)
 9 Proto RefCnt Flags       Type       State         I-Node Path
10 
11 # 创建一个基于上面容器的joined容器，发现其共享了上面的close容器中的网络
12 [root@server ~]# docker run --network container:join-base-container centos:latest netstat -al
13 Active Internet connections (servers and established)
14 Proto Recv-Q Send-Q Local Address           Foreign Address         State       
15 tcp        0      0 0.0.0.0:39439           0.0.0.0:*               LISTEN      
16 Active UNIX domain sockets (servers and established)
17 Proto RefCnt Flags       Type       State         I-Node Path

5. Open容器：没有网络容器，共享主机网络，并且对主机网络有完全的访问权。

 1 # 发现open容器里能访问主机所有的网络接口
 2 [root@server ~]#  docker run --network host centos:latest ip a
 3 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
 4     link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
 5     inet 127.0.0.1/8 scope host lo
 6        valid_lft forever preferred_lft forever
 7     inet6 ::1/128 scope host 
 8        valid_lft forever preferred_lft forever
 9 2: eno1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
10     link/ether 8c:ec:4b:ab:6d:38 brd ff:ff:ff:ff:ff:ff
11     inet 10.55.2.40/24 brd 10.55.2.255 scope global noprefixroute dynamic eno1
12        valid_lft 522693sec preferred_lft 522693sec
13     inet6 fe80::7b57:66c8:6d06:833d/64 scope link noprefixroute 
14        valid_lft forever preferred_lft forever
15 3: docker0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default 
16     link/ether 02:42:cc:a9:3a:68 brd ff:ff:ff:ff:ff:ff
17     inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0
18        valid_lft forever preferred_lft forever
19     inet6 fe80::42:ccff:fea9:3a68/64 scope link 
20        valid_lft forever preferred_lft forever
21 4: vboxnet0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
22     link/ether 0a:00:27:00:00:00 brd ff:ff:ff:ff:ff:ff
23     inet 192.168.99.1/24 brd 192.168.99.255 scope global vboxnet0
24        valid_lft forever preferred_lft forever
25     inet6 fe80::800:27ff:fe00:0/64 scope link 
26        valid_lft forever preferred_lft forever

6. 常用操作

四、Docker 卷和数据持久化

1. 简介：

1. 术语：一个主机或容器的目录树是由一组挂载点创建而成，这些挂载点描述了如何能构建出一个或多个文件系统。存储卷是容器目录树上的挂载点，提供了容器无关的数据管理方式。

2. 个人理解：将主机磁盘的某个目录挂载到容器的文件系统（主机上的这个目录就称为存储卷），那么在容器内对这个挂载点的操作实际上都是对主机上那个目录的操作。比如将主机目录 /opt/soft 挂载到容器的 /soft 目录，那么容器中对 /soft 的所有操作实际上都是对主机目录 /opt/soft 的操作。

2. 类型

1. 绑定挂载存储卷：使用用户提供的主机目录或文件，在启动容器时需要加入选项 -v <主机位置>:<容器挂载点>。

2. 管理存储卷：使用 Docker 的管理空间，在启动容器时需要加入选项 -v <容器挂载点>。Docker 守护进程会自动在主机文件系统（/var/lib/docker/volumes）中创建一个目录来挂载到容器中指定的挂载掉点。

3. 常用操作

 1 # 创建数据卷
 2 [root@server ~]# docker volume create --name volume1  [-d  指定位置]
 3 volume1
 4 
 5 # 查看数据卷列表信息
 6 [root@server ~]# docker volume ls
 7 DRIVER              VOLUME NAME
 8 local               412e102c656ee75de3db150c41fc9c3c21e2861ff9028a53aa49b25504e1e001
 9 local               81ad13949b48f53ab4917848fdaa8473ee9523bb18353b38925969f323bc166d
10 local               volume1
11 
12 # 查看数据卷详细信息
13 [root@server ~]# docker volume inspect volume1
14 [
15     {
16         "Name": "volume1",
17         "Driver": "local",
18         "Mountpoint": "/var/lib/docker/volumes/volume1/_data",
19         "Labels": {},
20         "Scope": "local"
21     }
22 ]
23 
24 # 删除数据卷
25 [root@server ~]# docker volume rm volume1
26 volume1
27 
28 # 挂载宿主机文件或目录到容器数据卷
29 ## 挂载文件
30 [root@server ~]# cat /opt/test.txt 
31 hello world!!!
32 [root@server ~]# docker run -it --name centos-file -v /opt/test.txt:/opt/test.txt:ro centos:latest 
33 [root@d62e52a32a07 /]# cat /opt/test.txt 
34 hello world!!!
35 
36 ## 挂载目录
37 [root@server ~]# ll /tmp/
38 total 0
39 drwx------ 2 root root 6 May 29 16:14 tmp.fJOTUQbyx3
40 drwx------ 2 root root 6 May 29 16:48 tmp.kt4W6bwra4
41 drwx------ 2 root root 6 May 29 16:10 tmp.xmy3qeNyIx
42 [root@server ~]# docker run --name centos-dir -v /tmp/:/opt/ centos:latest  ls -l /opt/                            
43 total 0
44 drwx------ 2 root root 6 May 29 16:14 tmp.fJOTUQbyx3
45 drwx------ 2 root root 6 May 29 16:48 tmp.kt4W6bwra4
46 drwx------ 2 root root 6 May 29 16:10 tmp.xmy3qeNyIx
47 
48 # 共享数据卷
49 [root@server ~]# docker run --name centos-shared -v /tmp/:/opt/ centos:latest
50 [root@server ~]# docker run --name centos --volumes-from centos-shared  centos:latest ls -l /opt/
51 total 0
52 drwx------ 2 root root 6 May 29 16:14 tmp.fJOTUQbyx3
53 drwx------ 2 root root 6 May 29 16:48 tmp.kt4W6bwra4
54 drwx------ 2 root root 6 May 29 16:10 tmp.xmy3qeNyIx
55 
56 # 备份数据卷
57 [root@server ~]# docker run --name centos-shared -v /tmp/:/opt/ centos:latest 
58 [root@server ~]# docker run --rm --volumes-from centos-shared -v $(pwd):/backup centos:latest tar cvf /backup/centos.tar /opt/                         
59 tar: Removing leading `/' from member names
60 /opt/
61 /opt/.ICE-unix/
62 /opt/.Test-unix/
63 /opt/.X11-unix/
64 /opt/.XIM-unix/
65 /opt/.font-unix/
66 /opt/ks-script-Rl3Umm
67 /opt/yum.log

五、Docker 资源限制

1. 简介

1. cgroup：是将任意进程进行分组化管理的Linux内核功能，限制某个或者某些进程的分配资源。

2. subsystem：用于控制cgroup中的进程行为的内核组件。

3. hierarchy：由cgroup组成的层级树，每个hierarchy都对应一个cgroup虚拟文件系统，都有系统上的所有task，此外低 level 的hierarchy 不能超过高 level 设定的资源上限。

2. subsystem（资源控制器）

1. blkio：控制块设备的访问，比如带宽等。

2. cpu：控制进程占用cpu的多少。

3. cpuacct：记录cgroup 中进程使用的 CPU 情况。

4. cpuset：为 cgroup 中的进程分配 CPU 和内存节点。

5. devices：控制进程对设备的访问。

6. freezer：挂起或者恢复 cgroup 中的进程。

7. memory：设定 cgroup 中进程的内存限制，统计使用的内存资源。

8. net_cls：使用等级识别符（classid）标记网络数据包，使得Linux 流量控制程序（tc）识别具体 cgroup 中的数据包。

3. 常用操作

 1 # CPU 资源配额控制
 2 ## CPU 份额配置
 3 [root@server ~]# docker run -itd --name cpu512 -c 512 centos:latest 
 4 426e23ed9c96b9482cd167d17ca79c57e140be2359191372a5a0bdfd10d73173
 5 [root@server ~]# top -p  $(docker inspect -f {{.State.Pid}} da8d71c623ce)
 6 top - 15:43:49 up 1 day, 23:51,  1 user,  load average: 0.00, 0.01, 0.05
 7 Tasks:   1 total,   0 running,   1 sleeping,   0 stopped,   0 zombie
 8 %Cpu(s):  0.3 us,  0.1 sy,  0.0 ni, 99.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
 9 KiB Mem :  8176044 total,  1236396 free,  1157452 used,  5782196 buff/cache
10 KiB Swap:        0 total,        0 free,        0 used.  6711724 avail Mem
11 
12 ## CPU 周期控制
13 docker run -tid --cpu-period 100000(周期) --cpu-quota200000(配额) centos:latest
14 <容器的完整长ID>
15 [root@server ~]# cat /sys/fs/cgroup/cpu/docker/<容器的完整长ID>/cpu.cfs_period_us
16 100000
17 [root@server ~]# cat /sys/fs/cgroup/cpu/docker/<容器的完整长ID>/cpu.cfs_quota_us
18 200000
19 
20 ## CPU 内核控制
21 [root@server ~]# docker run -itd --name cupset --cpuset-cpus="0,1" centos:latest
22 da8d71c623ce35105201d824234d476b065e8bd6e87b416d262599b7d2ac333f
23 [root@server ~]# cat /sys/fs/cgroup/cpuset/docker/<容器的完整长ID>/cpuset.cpus
24 0-1
25 
26 # 内存资源配额控制
27 -m 设置内存的使用限额
28 --memory-swap 设置内存和swap的使用限额
29 [root@server ~]# docker run -m 200M --memory-swap=300M centos:latest
30 
31 # Block IO 的限制
32 ## 限制 block IO（默认500） 
33 [root@server ~]# docker run -itd --name B --blkio-weight 300 centos:latest
34 
35 ## 限制 bps 和 iops
36 bps 是 byte per second，每秒读写的数据量。
37 iops 是 io per second，每秒 IO 的次数。
38 [root@server ~]# docker run -itd --device-write-bps /dev/sda:30MB centos:latest

六、Docker API

1. 种类

1. Docker Registry API：docker镜像仓库的api，通过操作这套API，你可以自由的自动化、程序化的管理你的镜像仓库。

2. Docker Hub API：用户管理操作的API，docker hub是使用校验和公共 namespaces 的方式来存储账户信息、认证账户、进行账户授权。API同时也允许操作相关的用户仓库和 library 仓库。

3. Docker Remote API：用于控制主机 Docker 服务端的 API，等价于 docker命令行客户端。有了它，你能远程操作docker容器，更重要的是你可以通过程序自动化运维docker进程。

2. 配置（需要重启 Docker）

1. 在 /etc/sysconfig/docker 文件中添加 OPTIONS=' -H tcp://0.0.0.0:2357 -H unix:///var/run/docker.sock '

2. 在 /usr/lib/systemd/system/docker.service 文件中 ExecStart 后面添加 -H tcp://0.0.0.0:2357 -H unix:///var/run/docker.sock

3. 使用

 1 #### 查看
 2 # 查看 docker 版本信息
 3 curl http://localhost:2357/version | python -mjson.tool
 4 
 5 # 查看 docker 详细信息
 6 curl http://localhost:2357/info | python -mjson.tool
 7 
 8 # 列出所有镜像
 9 curl http://localhost:2357/images/json | python -mjson.tool
10 
11 # 列出指定镜像
12 curl http://localhost:2357/images/images_id/json | python -mjson.tool
13 
14 # 列出所有容器
15 curl http://localhost:2357/containers/json | python -mjson.tool
16 
17 # 列出指定容器
18 curl http://localhost:2357/containers/contianer_id/json | python -mjson.tool
19 
20 # 查看 docker 系统文件的变更情况
21 curl http://localhost:2357/containers/contianer_id/changes/json | python -mjson.tool
22 
23 #### 生命周期
24 # 创建容器（mariadb数据库的容器，设置了密码是123456，监听端口是3306）
25 curl -X POST -H "Content-Type: application/json" -d '{
26     "Image": "mariadb",
27     "Env": ["MYSQL_ROOT_PASSWORD=123456"],
28     "ExposedPorts": {
29         "3306/tcp": {}
30     },
31     "HostConfig": {
32         "PortBindings": {
33             "3306/tcp": [{"HostIp": "","HostPort": "3306"}]
34         }
35     },
36     "NetworkSettings": {
37         "Ports": {
38             "5000/tcp": [{"HostIp": "0.0.0.0","HostPort": "3306"}]
39         }
40     }
41 }' http://localhost:2357/containers/create
42 
43 # 启动容器
44 curl -X POST http://127.0.0.1:8088/containers/{id}/start  
45 
46 # 停止容器
47 curl -X POST http://127.0.0.1:8088/containers/{id}/stop
48 
49 # 删除容器
50 curl -X POST http://127.0.0.1:8088/containers/{id}/rm

三：Docker 实例

一、应用容器化技术

1. supermin5 构建镜像

 1 # 安装
 2 [root@server ~]# yum install -y supermin5
 3 Loaded plugins: fastestmirror
 4 Loading mirror speeds from cached hostfile
 5 Resolving Dependencies
 6 --> Running transaction check
 7 ---> Package supermin5.x86_64 0:5.1.10-1.2.el7 will be installed
 8 --> Finished Dependency Resolution
 9 
10 # 预装镜像
11 [root@server ~]# supermin5 -v –prepare bash yum net-tools initscripts vi coreutils -o supermin.d
12 supermin: version: 5.1.10
13 supermin: rpm: detected RPM version 4.11
14 supermin: package handler: fedora/rpm
15 supermin: prepare: bash net-tools initscripts vi coreutils
16 supermin: packages specified on the command line:
17   - bash-4.2.46-12.el7.x86_64
18   - net-tools-2.0-0.17.20131004git.el7.x86_64
19   - initscripts-9.49.39-1.el7_4.1.x86_64
20   - coreutils-8.22-11.el7.x86_64
21 ...
22 supermin: renaming supermin.d.9ohzr3uh to supermin.d
23 
24 # 构建镜像
25 [root@server ~]# supermin5 -v --build --format chroot supermin.d/ -o appliance.d
26 supermin: version: 5.1.10
27 supermin: rpm: detected RPM version 4.11
28 supermin: package handler: fedora/rpm
29 supermin: build: supermin.d/
30 supermin: build: visiting supermin.d/base.tar.gz type gzip base image (tar)
31 supermin: build: visiting supermin.d/packages type uncompressed packages
32 ...
33 supermin: renaming appliance.d.t7dbj8kr to appliance.d
34 
35 # 使用yum安装软件
36 [root@server ~]# echo 7 > appliance.d/etc/yum/vars/releasever
37 
38 # 构建网络(如果需要)
39 [root@server ~]# cp /etc/resolv.conf appliance.d/etc
40 
41 # 将构建镜像归档
42 [root@server ~]# tar --numeric-owner -cpf centos-7.tar -C appliance.d/ .
43 
44 # 从归档文件启动镜像并设置tag
45 [root@server ~]# cat centos-7.tar | docker import - 192.168.200.105:5000/centos-7:latest
46 sha256:b1e7942497d9372d43ad7bc0bfc27687dad6e77f100e7242139592efc2ab4e62
47 
48 # 将镜像上传到仓库
49 [root@server ~]# docker push 192.168.200.105:5000/centos-7:latest
50 The push refers to a repository [192.168.200.51:5000/centos-7]
51 11f2f8c2668b: Pushed 
52 latest: digest: sha256:fc47a231f23c189dd93ceeb1bba5aceca50f394003425eaabfbb2062b2feaa9c size: 528
53 
54 # 查看镜像信息
55 [root@server ~]# docker images 192.168.200.105:5000/centos-7:latest
56 REPOSITORY                     TAG                 IMAGE ID            CREATED             SIZE
57 192.168.200.51:5000/centos-7   latest              5e83db682966        2 minutes ago       213.4 MB

2. Dockerfile 创建镜像

1. 简介

1. Dockerfile是一个包含用于组合映像的命令的文本文档，可以在命令行中调用任何命令。 Docker 通过读取 Dockerfile 中的指令自动生成映像。

2. Docker build命令用于从 Dockerfile 构建映像，可以使用 -f 标志指向文件系统中任何位置的Dockerfile。

2. 常用命令

3. 示例

 1 # This my first nginx Dockerfile
 2 # Version 1.0
 3 
 4 # Base images 基础镜像
 5 FROM centos
 6 
 7 # MAINTAINER 维护者信息
 8 LABLE maintainer="mj_1028@qq.com" 
 9 
10 # ENV 设置环境变量
11 ENV PATH /usr/local/nginx/sbin:$PATH
12 
13 # ADD  文件放在当前目录下，拷过去会自动解压
14 ADD nginx-1.8.0.tar.gz /usr/local/  
15 ADD epel-release-latest-7.noarch.rpm /usr/local/  
16 
17 # RUN 执行以下命令 
18 RUN rpm -ivh /usr/local/epel-release-latest-7.noarch.rpm
19 RUN yum install -y wget lftp gcc gcc-c++ make openssl-devel pcre-devel pcre && yum clean all
20 RUN useradd -s /sbin/nologin -M www
21 
22 # WORKDIR 相当于cd
23 WORKDIR /usr/local/nginx-1.8.0 
24 
25 RUN ./configure --prefix=/usr/local/nginx --user=www --group=www --with-http_ssl_module --with-pcre && make && make install
27 RUN echo "daemon off;" >> /etc/nginx.conf
28 
29 # EXPOSE 暴露端口
30 EXPOSE 80
31 
32 # CMD 运行以下命令
33 CMD ["nginx"]

二、Dockerfile 构建 MySQL

  1 # 编写数据库建表脚本
  2 [root@server mysql]# cat build_table.sh 
  3 #!/bin/bash
  4 mysqld_safe &
  5 sleep 5
  6 mysql -uroot -e "GRANT ALL PRIVILEGES ON *.* TO '$MYSQL_USER'@'%' IDENTIFIED BY '$MYSQL_PASS'  WITH GRANT OPTION;"
  7 mysql -uroot -e "GRANT ALL PRIVILEGES ON *.* TO '$MYSQL_USER'@'localhost' IDENTIFIED BY '$MYSQL_PASS'  WITH GRANT OPTION;"
  8 mysql -e "create database chinaskills;"
  9 mysql -e "create table chinaskills.company(name char(20) not null,years int not null)DEFAULT CHARSET=utf8;"
 10 mysql -e "insert into chinaskills.company values('mm',2020),('dd',2020);"
 11 
 12 # 编写 yum 源文件
 13 [root@server mysql]# cat local.repo 
 14 [centos]
 15 name=centos
 16 baseurl=file:///opt/centos
 17 gpgcheck=0
 18 enabled=1
 19 [pass]
 20 name=pass
 21 baseurl=file:///opt/pass/docker
 22 gpgcheck=0
 23 enabled=1
 24 
 25 # 编写 Dockerfile
 26 [root@server mysql]# cat Dockerfile 
 27 # 基础镜像
 28 FROM 192.168.200.51:5000/centos-7:latest
 29 # 维护者信息
 30 LABLE maintainer="mj_1028@qq.com"
 31 # 使用当前系统的 yum 源文件
 32 RUN rm -f /etc/yum.repos.d/*
 33 ADD local.repo /etc/yum.repos.d/
 34 # 安装MySQL服务，初始化数据库，设置用户名和密码，支持中文
 35 RUN yum install -y mariadb-server 
 36 RUN mysql_install_db --user=mysql
 37 ENV MYSQL_USER xiandian
 38 ENV MYSQL_PASS xiandian
 39 ENV LC_ALL en_US.UTF-8
 40 # 运行并修改数据库脚本
 41 ADD build_table.sh /docker/mysql/build_table.sh
 42 RUN chmod +x /docker/mysql/build_table.sh
 43 RUN /docker/mysql/build_table.sh
 44 # 暴露3306端口，并以后台安全模式启动
 45 EXPOSE 3306
 46 CMD mysqld_safe
 47 
 48 # 构建镜像
 49 [root@server mysql]# docker build -t mysql:latest .
 50 Sending build context to Docker daemon 5.632 kB
 51 Step 1 : FROM 192.168.200.51:5000/centos-7:latest
 52  ---> 6300524e4fcb
 53 Step 2 : LABEL maintainer "mj_1028@qq.com"
 54  ---> Using cache
 55  ---> 297bb01a36e7
 56 Step 3 : RUN rm -f /etc/yum.repos.d/*
 57  ---> Using cache
 58  ---> 5cd2c60db6e4
 59 Step 4 : ADD local.repo /etc/yum.repos.d/
 60  ---> Using cache
 61  ---> 6bf93249441b
 62 Step 5 : RUN yum install -y mariadb-server
 63  ---> Using cache
 64  ---> c032f3770d64
 65 Step 6 : RUN mysql_install_db --user=mysql
 66  ---> Using cache
 67  ---> cebd6468488a
 68 Step 7 : ENV MYSQL_USER xiandian
 69  ---> Using cache
 70  ---> 4f0a879d55cd
 71 Step 8 : ENV MYSQL_PASS xiandian
 72  ---> Using cache
 73  ---> 168de6eb69ab
 74 Step 9 : ENV LC_ALL en_US.UTF-8
 75  ---> Using cache
 76  ---> a8fa8e895f78
 77 Step 10 : ADD build_table.sh /docker/mysql/build_table.sh
 78  ---> Using cache
 79  ---> 31201ac69e2a
 80 Step 11 : RUN chmod +x /docker/mysql/build_table.sh
 81  ---> Using cache
 82  ---> 27069a74cb3d
 83 Step 12 : RUN /docker/mysql/build_table.sh
 84  ---> Using cache
 85  ---> 41f7ef5e31a7
 86 Step 13 : EXPOSE 3306
 87  ---> Using cache
 88  ---> 0e4dab8114cf
 89 Step 14 : CMD mysqld_safe
 90  ---> Using cache
 91  ---> 1835da94d00e
 92 Successfully built 1835da94d00e
 93 
 94 # 启动容器，登录数据库，查看数据库列表
 95 [root@server mysql]# docker run -itP --name mysql -e MYSQL_ROOT_PASSWORD=000000 mysql:latest /bin/bash
 96 bash-4.2# mysql -uxiandian -pxiandian
 97 Welcome to the MariaDB monitor.  Commands end with ; or \g.
 98 Your MariaDB connection id is 4
 99 Server version: 5.5.56-MariaDB MariaDB Server
100 
101 Copyright (c) 2000, 2017, Oracle, MariaDB Corporation Ab and others.
102 
103 Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
104 
105 MariaDB [(none)]> show databases;
106 +--------------------+
107 | Database           |
108 +--------------------+
109 | information_schema |
110 | mysql              |
111 | performance_schema |
112 | test              |
113 | chinaskills            |
114 +--------------------+
115 4 rows in set (0.01 sec)

三、Dockerfile 构建 Apache+PHP

  1 # 编写 PHP 远程访问 MySQL
  2 [root@server ~]# cat test.php 
  3 <?php
  4   $con = mysql_connect(getenv("MYSQL_ADDR"),getenv("MYSQL_USER"),getenv("MYSQL_PASS"));
  5   if (!$con)
  6     {
  7       die('Could not connect: ' . mysql_error());
  8     }
  9   mysql_select_db("chinaskills", $con);
 10   $result = mysql_query("SELECT * FROM company");
 11   echo "<table border='1'>
 12   <tr>
 13   <th>NAME</th>
 14   <th>YEARS</th>
 15   </tr>";
 16   while($row = mysql_fetch_array($result))
 17     {
 18       echo "<tr>";
 19       echo "<td>" . $row['name'] . "</td>";
 20       echo "<td>" . $row['years'] . "</td>";
 21       echo "</tr>";
 22     }
 23     echo "</table>";
 24  
 25   mysql_close($con);
 26 ?>
 27 
 28 # 编写 Dockerfile
 29 [root@server ~]# cat Dockerfile 
 30 FROM 192.168.200.51:5000/centos-7:latest
 31 LABEL maintainer="mj_1028@qq.com"
 32 RUN rm -f /etc/yum.repos.d/*
 33 ADD local.repo /etc/yum.repos.d/local.repo
 34 WORKDIR /root/
 35 RUN yum install -y httpd php php-mysql 
 36 RUN mkdir -p /var/log/httpd
 37 RUN mkdir -p /var/www/html
 38 ENV MYSQL_ADDR 172.17.0.5
 39 ENV MYSQL_USER xiandian
 40 ENV MYSQL_PASS xiandian
 41 ENV TERM linux
 42 ENV LC_ALL en_US.UTF-8
 43 ADD test.php /var/www/html/test.php
 44 EXPOSE 80
 45 ADD run.sh /root/run.sh
 46 RUN chmod u+x /root/run.sh
 47 CMD /root/run.sh
 48 
 49 # 构建
 50 [root@server ~]# docker build -t apache-php:laetst .
 51 Sending build context to Docker daemon 32.77 kB
 52 Step 1 : FROM 192.168.200.51:5000/centos-7:latest
 53  ---> 6300524e4fcb
 54 Step 2 : LABEL maintainer "mj_1028@qq.com"
 55  ---> Using cache
 56  ---> 297bb01a36e7
 57 Step 3 : RUN rm -f /etc/yum.repos.d/*
 58  ---> Using cache
 59  ---> 5cd2c60db6e4
 60 Step 4 : ADD local.repo /etc/yum.repos.d/local.repo
 61  ---> Using cache
 62  ---> 6bf93249441b
 63 Step 5 : WORKDIR /root/
 64  ---> Using cache
 65  ---> 86be0e478fd9
 66 Step 6 : RUN yum install -y httpd php php-mysql
 67  ---> Using cache
 68  ---> 40756572de7f
 69 Step 7 : RUN mkdir -p /var/log/httpd
 70  ---> Using cache
 71  ---> 457d374ff59a
 72 Step 8 : RUN mkdir -p /var/www/html
 73  ---> Using cache
 74  ---> 738f8d821172
 75 Step 9 : ENV MYSQL_ADDR 172.17.0.5
 76  ---> Using cache
 77  ---> 6348e4d33a2b
 78 Step 10 : ENV MYSQL_USER xiandian
 79  ---> Using cache
 80  ---> d3ba7946fb52
 81 Step 11 : ENV MYSQL_PASS xiandian
 82  ---> Using cache
 83  ---> 3d40f9cfe126
 84 Step 12 : ENV TERM linux
 85  ---> Using cache
 86  ---> 1a6ad56ec0e8
 87 Step 13 : ENV LC_ALL en_US.UTF-8
 88  ---> Using cache
 89  ---> ed9fdc4a238b
 90 Step 14 : ADD test.php /var/www/html/test.php
 91  ---> Using cache
 92  ---> 3d45b3c49b07
 93 Step 15 : EXPOSE 80
 94  ---> Using cache
 95  ---> 1609552d6493
 96 Step 16 : ADD run.sh /root/run.sh
 97  ---> Using cache
 98  ---> 7b00521525e8
 99 Step 17 : RUN chmod u+x /root/run.sh
100  ---> Using cache
101  ---> 411bd471e1ee
102 Step 18 : CMD /root/run.sh
103  ---> Using cache
104  ---> c719019aa274
105 Successfully built c719019aa274
106 
107 # 访问
108 [root@server ~]# curl http://192.168.200.51:8096/test.php
109 <table border='1'>
110    <tr>
111      <th>NAME</th>
112      <th>YEARS</th>
113    </tr>
114    <tr>
115       <td>mm</td>
116       <td>2020</td>
117     </tr>
118     <tr>
119       <td>dd</td>
120       <td>2020</td>
121     </tr>
122 </table>

四、Dockerfile 构建 Tomcat

 1 # 编辑 Dockerfile
 2 [root@server ~]# cat Dockerfile
 3 FROM 192.168.200.51:5000/centos-7:latest
 4 LABEL maintainer="mj_1028@qq.com"
 5 RUN rm -f /etc/yum.repos.d/
 6 ADD local.repo /etc/yum.repos.d/local.repo
 7 RUN yum install -y java unzip
 8 ENV LC_ALL en_US.UTF-8
 9 ADD apache-tomcat.zip  /root/apache-tomcat.zip
10 RUN unzip /root/apache-tomcat.zip -d /root/
11 EXPOSE 8080
12 RUN chmod u+x /root/apache-tomcat-6/bin/
13 ADD index.html /root/apache-tomcat-6/webapps/ROOT/index.html
14 CMD /root/apache-tomcat-6/bin/catalina.sh
15 
16 # 构建
17 [root@server ~]# docker build -t tomcat:v1.0 .
18 Sending build context to Docker daemon 5.055 MB
19 Step 1 : FROM 192.168.200.51:5000/centos-7:latest
20  ---> 6300524e4fcb
21 Step 2 : LABEL maintainer "mj_1028@qq.com"
22  ---> Using cache
23  ---> 297bb01a36e7
24 Step 3 : RUN rm -f /etc/yum.repos.d/
25  ---> Using cache
26  ---> 5cd2c60db6e4
27 Step 4 : ADD local.repo /etc/yum.repos.d/local.repo
28  ---> Using cache
29  ---> 65c3b9a5e36c
30 Step 5 : RUN yum install -y java unzip
31  ---> Using cache
32  ---> c52f6b212a3e
33 Step 6 : ENV LC_ALL en_US.UTF-8
34  ---> Using cache
35  ---> c79e93ff2f1a
36 Step 7 : ADD apache-tomcat.zip /root/apache-tomcat.zip
37  ---> Using cache
38  ---> 1d9559d21467
39 Step 8 : RUN unzip /root/apache-tomcat.zip -d /root/
40  ---> Using cache
41  ---> cff845220459
42 Step 9 : EXPOSE 8080
43  ---> Using cache
44  ---> 3c7b78ef3e32
45 Step 10 : RUN chmod u+x /root/apache-tomcat-6/bin/
46  ---> Using cache
47  ---> db348be4e9a7
48 Step 11 : ADD index.html /root/apache-tomcat-6/webapps/ROOT/index.html
49  ---> Using cache
50  ---> 8f1be41345b2
51 Step 12 : CMD /root/apache-tomcat-6/bin/catalina.sh
52  ---> Using cache
53  ---> d1fadb90c70f
54 Successfully built d1fadb90c70f57 
58 #  访问并查看JDK及Tomcat版本信息
59 [root@server ~]# curl 192.168.200.51:8080
60 Xiandian WEB
61 
62 bash-4.2# java -version
63 openjdk version "1.8.0_102"
64 OpenJDK Runtime Environment (build 1.8.0_102-b14)
65 OpenJDK 64-Bit Server VM (build 25.102-b14, mixed mode)
66 
67 bash-4.2# ./version.sh 
68 Server version: Apache Tomcat/6.0.20
69 Server built:   May 14 2009 01:13:50
70 Server number:  6.0.20.0
71 OS Name:        Linux
72 OS Version:     3.10.0-229.el7.x86_64
73 Architecture:   amd64
74 JVM Version:    1.8.0_102-b14
75 JVM Vendor:     Oracle Corporation

__EOF__

本文作者：萌萌哥的春天
本文链接：https://www.cnblogs.com/mh20131118/p/12261590.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！