Docker学习笔记（二）

发表于 | 更新于: | 分类于 | 浏览 次
字数统计: 4.7k 字 | 阅读时长 ≈ 22 分钟

Docker数据卷

数据卷介绍

数据卷的技术可以理解为将宿主机上的一个目录与Docker中的目录数据共享的技术。

带来的好处：

  1. 数据的持久化（ 备份）
  2. 方便的文件修改（从外部直接修改Docker内的文件）
  3. 容器间数据共享（多个容器共享数据卷）

数据卷的简单使用

命令直接挂载

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
docker run -v 主机目录:容器内目录
# 说明：主机目录与容器内目录的文件互相同步
# 示例
# 1. 进入/tmp目录，查看目录下文件，没有centos
[root@ramon ~]# cd /tmp/
[root@ramon tmp]# ls
systemd-private-19e7c3ab56d6419d82a4133b3f236d2f-ntpd.service-Ewqdpr
# 2. docker运行centos容器，挂载容器中/home到本地/tmp/centos
[root@ramon tmp]# docker run -it -v /tmp/centos:/home centos /bin/bash
[root@dbfc859b5431 /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
[root@dbfc859b5431 /]# cd home/
[root@dbfc859b5431 home]# ls
# 3. 在容器中写入test文件
[root@dbfc859b5431 home]# echo "hello world" > test
[root@dbfc859b5431 home]# cat test
hello world
# 4. C+p+q退出镜像
[root@dbfc859b5431 home]# [root@ramon tmp]#
# 5. 查看宿主机/tmp下多了centos目录，下面的确有test文件
[root@ramon tmp]# ls
centos  systemd-private-19e7c3ab56d6419d82a4133b3f236d2f-ntpd.service-Ewqdpr
[root@ramon tmp]# cd centos/
[root@ramon centos]# ls
test
[root@ramon centos]# cat test
hello world
[root@ramon centos]# ls
test
# 6. 在宿主机写入新的文件host_test
[root@ramon centos]# echo "host test" > host_test
[root@ramon centos]# ls
host_test  test
# 7. 进入centos的容器
[root@ramon centos]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED            
dbfc859b5431        centos              "/bin/bash"              5 minutes ago
c19372c823a6        tomcat              "catalina.sh run"        8 hours ago 
07ab15e34e1b        nginx               "/docker-entrypoint.…"   8 hours ago 
[root@ramon centos]# docker exec -it dbfc859b5431 /bin/bash
[root@dbfc859b5431 /]# cd /home/
# 8. 宿主机的修改同步到了容器中
[root@dbfc859b5431 home]# ls
host_test  test
[root@dbfc859b5431 home]# cat host_test
host test
# 9. 删除容器
[root@ramon centos]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED           
dbfc859b5431        centos              "/bin/bash"              26 minutes ago 
c19372c823a6        tomcat              "catalina.sh run"        8 hours ago
07ab15e34e1b        nginx               "/docker-entrypoint.…"   8 hours ago  
[root@ramon centos]# docker rm -f dbfc859b5431
dbfc859b5431
[root@ramon centos]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED
c19372c823a6        tomcat              "catalina.sh run"        8 hours ago
07ab15e34e1b        nginx               "/docker-entrypoint.…"   8 hours ago 
# 10. 数据持久化到了本地
[root@ramon centos]# ll
总用量 8
-rw-r--r-- 1 root root 10 6月  21 00:40 host_test
-rw-r--r-- 1 root root 12 6月  21 00:35 test
# 11. 重新拉起一个容器，文件也同步到了其中
[root@ramon centos]# docker run -it -v /tmp/centos:/home --name centos02 centos /bin/bash
[root@4ed68a9bf8a6 /]# ls /home/
host_test  test

还可以使用DockerFile进行挂载，这个下面介绍DockerFile会详细讲，现在知道有这个方式就行了。

匿名挂载和具名挂载

理解前先学习一个数据卷管理的命令

1
2
3
4
5
6
7
8
9
10
11
12
docker volume
# 选项
[root@ramon centos]# docker help volume
Usage:  docker volume COMMAND
Manage volumes
Commands:
  create      Create a volume
  inspect     Display detailed information on one or more volumes
  ls          List volumes
  prune       Remove all unused local volumes
  rm          Remove one or more volumes
# 根据上面我们可以知道，这个主要是对数据卷进行管理操作的命令，包括创建删除、查看列表、查看数据卷信息等

了解了上面的命令之后，我们再来进行下面实战操作

dokcer volume

当我们不选择指定本地挂在路径的时候，Docker会为我们创建一个Volume进行数据保存，匿名挂载就是不写明数据卷的名字，这时候就是以哈希值命名，而具名挂载就是指定挂载的名字，这时候可以看到，volume的名字就是我们指定的名字。

我们如果想要知道这个volume在宿主机上的具体路径时，可以通过docker volume inspect $VOLUME_ID获取，如下图所示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
[root@ramon ~]# docker volume inspect nginx02
[
    {
        "CreatedAt": "2020-06-21T01:20:45+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/nginx02/_data",
        "Name": "nginx02",
        "Options": null,
        "Scope": "local"
    }
]
[root@ramon ~]# ls /var/lib/docker/volumes/nginx02/_data/
conf.d  fastcgi_params  koi-utf  koi-win  mime.types  modules  nginx.conf  scgi_params  uwsgi_params  win-utf
[root@ramon ~]#

整理下挂载方式如下：

1
2
3
4
5
6
7
-v 本地路径:Docker路径    # 指定目录挂载
-v Dokcer内路径          # 匿名挂载
-v 卷名:Dokcer内路径      # 具名挂载

# 多提一下，挂载也可以指定挂载权限，以匿名挂载为例：
-v Docker内路径:ro       # Docker对数据卷权限只读
-v Docker内路径:rw       # Dokcer对数据卷权限读写

容器间数据卷共享

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
docker run --volumes-from $CONTAINER
# 通过--volumes—from选项选中运行中的容器进行数据卷共享
# 示例
# 1. 创建带数据卷的centos01
[root@ramon ~]# docker run -it -v centos01:/home --name centos01 centos
# 2. 进入到/home下创建centos01文件
[root@30c20475120e /]# cd /home/
[root@30c20475120e home]# echo centos01 test > centos01
[root@30c20475120e home]# cat centos01
centos01 test
[root@30c20475120e home]# 
# 3. 创建继承centos01数据卷的centos02
[root@ramon ~]# docker run -it --name centos02 --volumes-from centos01 centos
# 4. 进入/home下发现有centos01文件，并且内容也是对应的
[root@248ca278f504 /]# cd /home/
[root@248ca278f504 home]# ls
centos01
[root@248ca278f504 home]# cat centos01
centos01 test
# 5. 创建centos02文件
[root@248ca278f504 home]# echo centos02 test > centos02
[root@248ca278f504 home]# ls
centos01  centos02
# 6. 进入centos01容器，检查发现centos02文件同步过来了
[root@ramon ~]# docker attach centos01
[root@30c20475120e home]# ls
centos01  centos02
[root@30c20475120e home]# cat centos02
centos02 test
# 7. 查看发现只有一个数据卷centos01
[root@ramon ~]# docker volume ls
DRIVER              VOLUME NAME
local               centos01

Docker镜像详解

什么是Docker镜像

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

我的理解：Docker镜像就可以理解为一个自带运行环境的软件包，运行这个文件就可以获取一个Docker容器。

Docker镜像基本操作

前面的文章中我们已经介绍了一些镜像的基本操作，比如镜像的查找（search）、下载（pull）、查看（images）、删除（rmi）等，今天对其他镜像相关的命令进行介绍。

1. 镜像提交

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
docker commit
# 使用场景：1. 保存当前的环境 2. 准备上传的镜像
# 选项
[root@ramon ~]# docker help commit
Usage:  docker commit [OPTIONS] CONTAINER [REPOSITORY[:TAG]]
Create a new image from a container's changes
Options:
  -a, --author string    Author (e.g., "John Hannibal Smith <hannibal@a-team.com>")
  -c, --change list      Apply Dockerfile instruction to the created image
  -m, --message string   Commit message
  -p, --pause            Pause container during commit (default true)
  
# 示例
# 1. 查看启动的tomcat实例（修改了其中webapp的内容）
[root@ramon ~]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED            
c19372c823a6        tomcat              "catalina.sh run"        2 minutes ago
07ab15e34e1b        nginx               "/docker-entrypoint.…"   4 minutes ago
# 2. 将容器提交为一个新的镜像
[root@ramon ~]# docker commit -a="ramon" -m="add webapps" c19372c823a6 ramon_tomcat:1.0
sha256:667e7f63a6e3478fcb17db1a759e7e98b4d1242c188973e3ae7df096cdcaf7f2
# 3. 镜像已生成
[root@ramon ~]# docker images
REPOSITORY            TAG                 IMAGE ID            CREATED             SIZE
ramon_tomcat          1.0                 667e7f63a6e3        8 seconds ago       652MB
tomcat                latest              2eb5a120304e        10 days ago         647MB
nginx                 latest              2622e6cca7eb        10 days ago         132MB
[root@ramon ~]#

2. 镜像导出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
docker save
# 将镜像导出一个tar包进行保存
# 选项
[root@ramon ~]# docker help save
Usage:  docker save [OPTIONS] IMAGE [IMAGE...]
Save one or more images to a tar archive (streamed to STDOUT by default)
Options:
  -o, --output string   Write to a file, instead of STDOUT

# 示例
[root@ramon ~]# docker images
REPOSITORY            TAG                 IMAGE ID            CREATED             SIZE
ramon_tomcat          1.0                 667e7f63a6e3        9 minutes ago       652MB
tomcat                latest              2eb5a120304e        10 days ago         647MB
nginx                 latest              2622e6cca7eb        10 days ago         132MB
[root@ramon ~]# docker save -o ramon_tomcat.tar ramon_tomcat:1.0
[root@ramon ~]# ls ramon_tomcat.tar
ramon_tomcat.tar

3. 镜像导入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
docker load
# 导入上个命令导出的tar包，可以用于离线的场合
# 选项
[root@ramon ~]# docker help load
Usage:  docker load [OPTIONS]
Load an image from a tar archive or STDIN
Options:
  -i, --input string   Read from tar archive file, instead of STDIN
  -q, --quiet          Suppress the load output
  
# 示例
[root@ramon ~]# docker images
REPOSITORY            TAG                 IMAGE ID            CREATED             SIZE
tomcat                latest              2eb5a120304e        10 days ago         647MB
nginx                 latest              2622e6cca7eb        10 days ago         132MB
[root@ramon ~]# docker load -i ramon_tomcat.tar
7c1351004b6f: Loading layer [==================================================>]  5.339MB/5.339MB
Loaded image: ramon_tomcat:1.0
[root@ramon ~]# docker images
REPOSITORY            TAG                 IMAGE ID            CREATED             SIZE
ramon_tomcat          1.0                 667e7f63a6e3        13 minutes ago      652MB
tomcat                latest              2eb5a120304e        10 days ago         647MB
nginx                 latest              2622e6cca7eb        10 days ago         132MB

4. 容器导出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
docker export
# 导出容器文件系统
# 选项
[root@ramon ~]# docker help export
Usage:  docker export [OPTIONS] CONTAINER
Export a container's filesystem as a tar archive
Options:
  -o, --output string   Write to a file, instead of STDOUT
  
# 实战
[root@ramon ~]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             
c19372c823a6        tomcat              "catalina.sh run"        6 hours ago
07ab15e34e1b        nginx               "/docker-entrypoint.…"   6 hours ago
[root@ramon ~]# docker export -o tomcat_export.tar c19372c823a6
[root@ramon ~]# ls tomcat_export.tar
tomcat_export.tar

5. 导入容器文件系统为镜像

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
docker import
# 选项
[root@ramon ~]# docker import --help
Usage:  docker import [OPTIONS] file|URL|- [REPOSITORY[:TAG]]
Import the contents from a tarball to create a filesystem image
Options:
  -c, --change list       Apply Dockerfile instruction to the created image
  -m, --message string    Set commit message for imported image
      --platform string   Set platform if server is multi-platform capable
      
# 示例
[root@ramon ~]# docker images
REPOSITORY            TAG                 IMAGE ID            CREATED             SIZE
tomcat                latest              2eb5a120304e        10 days ago         647MB
nginx                 latest              2622e6cca7eb        10 days ago         132MB
[root@ramon ~]# docker import tomcat_export.tar tomcat_export:1.0
sha256:a342ee4b2fa16d5eea4bbc89d6b1444b56578fe1fe5d44c43d2e9e167f4b40da
[root@ramon ~]# docker images
REPOSITORY            TAG                 IMAGE ID            CREATED             SIZE
tomcat_export         1.0                 a342ee4b2fa1        5 seconds ago       644MB
tomcat                latest              2eb5a120304e        10 days ago         647MB
nginx                 latest              2622e6cca7eb        10 days ago         132MB

6. 展示镜像制作流程

1
2
3
4
5
6
7
8
9
10
11
12
docker history
# 选项
[root@ramon ~]# docker help history
Usage:  docker history [OPTIONS] IMAGE
Show the history of an image
Options:
      --format string   Pretty-print images using a Go template
  -H, --human           Print sizes and dates in human readable format (default true)
      --no-trunc        Don't truncate output
  -q, --quiet           Only show numeric IDs
  
# 示例见下图（太大放不下）
docker history

这里要说明下，可以看到镜像是一个命令一层的，在下面我们会对Dokcer镜像原理进行详细介绍，看完原理后再看这里就会有不一样的感觉。

##save-load、export-import的区别

这两对命令都是导入导出，官方介绍load-save是针对镜像导入导出，而export-import是针对容器进行导入导出，那我们能不能混用呢？当然不可以了，这里我们对比下导出的文件内容：

load/export对比图

先看下右边export导出的文件，是一个完整的文件系统的内容，而左边save保存的内容则为一个一个的文件夹及配对的VERSION、json、layer.tar文件，这个就是我们下面要讲的Docker镜像内部了，一个分层的UnionFS（联合文件系统）。

Docker镜像原理

Docker镜像前面已经说了，就是一个自带运行环境的软件包，而Dokcer镜像底层使用的技术为UnionFS（联合文件系统），通过这个技术，Docker镜像实现分层的机制，大大减少镜像的存储。下面我们就先来介绍下UnionFS。

UnionFS

介绍

UnionFS的功能就像名字一样，联合文件系统 — 将多个目录内容（可以是物理位置分开）联合挂载到一个目录下，并且允许可读和可读写的目录并存，将可读目录的修改保存到可写目录下

实践

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
# 实践出真理，不过centos的联合文件系统overlay2显示不支持，这里就直接用我的ubuntu 16.04的机器测试了
# 测试的联合文件系统 aufs（不同linux发行版实现不一样）
# 1. 首先有如下目录
➜ /home/gewuang/aufs > tree
.
|-- dir01
|   `-- file01
|-- dir02
|   `-- file02
`-- mnt
3 directories, 2 files
# 2. 指定aufs文件系统挂在dir01和dir02到当前目录下的mnt目录
# 这里dir01在前面，所以dir01在文件系统作为可写层，dir02是只读层
➜ /home/gewuang/aufs > sudo mount -t aufs -o dirs=./dir01:./dir02 none ./mnt
# 3. 挂载成功后可以看到mnt下多出了其他两个目录的文件
➜ /home/gewuang/aufs > tree
.
|-- dir01
|   `-- file01
|-- dir02
|   `-- file02
`-- mnt
    |-- file01
    `-- file02
3 directories, 4 files
# 4. 修改mnt下的file02文件
➜ /home/gewuang/aufs > cd mnt
➜ /home/gewuang/aufs/mnt > echo mnt test >> file02
➜ /home/gewuang/aufs/mnt > cat file02
dir02 test
mnt test
# 5. 可以发现dir02（只读）下的文件并没有被修改，而是在dir01（读写）写时复制了一个file02文件
➜ /home/gewuang/aufs/mnt > cat ../dir02/file02
dir02 test
➜ /home/gewuang/aufs/mnt > ls ../dir01
file01  file02
➜ /home/gewuang/aufs/mnt > cat ../dir01/file02
dir02 test
mnt test
# 6. 这里删除mnt下的file02文件后，dir02（只读）的file02文件并没有被删除
# 而是dir01删除了文件并增加了一个.wh.file02，这样在mnt目录下就看不到dir02（只读）的file02文件了
➜ /home/gewuang/aufs/mnt > rm file02
➜ /home/gewuang/aufs/mnt > cd ..
➜ /home/gewuang/aufs > tree
.
|-- dir01
|   `-- file01
|-- dir02
|   `-- file02
`-- mnt
    `-- file01
3 directories, 3 files
➜ /home/gewuang/aufs > cd dir01
➜ /home/gewuang/aufs/dir01 > ls -la
total 20
drwxrwxr-x 4 gewuang gewuang 4096 Jun 21 14:09 .
drwxrwxr-x 5 gewuang gewuang 4096 Jun 21 14:05 ..
-r--r--r-- 2 root    root       0 Jun 21 14:06 .wh..wh.aufs
drwx------ 2 root    root    4096 Jun 21 14:06 .wh..wh.orph
drwx------ 2 root    root    4096 Jun 21 14:06 .wh..wh.plnk
-r--r--r-- 2 root    root       0 Jun 21 14:06 .wh.file02
-rw-rw-r-- 1 gewuang gewuang   11 Jun 21 14:05 file01

layer

简单介绍了UnionFS，我们再看看下镜像的层次设计。

用户制作镜像时候的每个操作都会生成一个层，每个层都是一个增量的rootfs（目录），这里可以查看之前docker history $IMAGE_ID的显示：

注：rootfs是操作系统所包含的文件、配置和目录，不包含操作系统内核，这也是容器体积小的原因

docker history

可以看到nginx镜像的制作流程和层级关系，通过UnionFS一层一层叠加联合最终得到我们的nginx镜像。

而对于一些相同操作的层是可以共享的，比如镜像A与镜像B都有centos和go的层级，就可以共享这些内容，这个在我们使用docker pull $IMAGE_ID的时候看到过，这样大大减少了镜像的存储空间，加快了下载速度。

一个容器在启动的时候从下往上分为以下三个层：

  1. 只读层：只读目录，不可修改
  2. Init层：Dokcer项目的内部层，放置一些专属的初始化文件，docker commit的时候不会包含
  3. 可读写层：运行后的修改都会放在这一层（写时复制），相当于快照

具体文件可以通过docker inspect查看。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
[root@ramon ~]# docker ps -a
CONTAINER ID        IMAGE                 COMMAND                  CREATED   
3822c5a6bef4        nginx                 "/docker-entrypoint.…"   15 hours ago
c19372c823a6        tomcat                "catalina.sh run"        23 hours ago
07ab15e34e1b        nginx                 "/docker-entrypoint.…"   23 hours ago
[root@ramon ~]# docker inspect -f {{'json .GraphDriver'}} 3822c5a6bef4
{
    "Data": {
        "LowerDir": "/var/lib/docker/overlay2/fe95bb65ff08221b1a55dfef103051685569e7d28b7c37acd1bad636a40b41b0-init/diff:/var/lib/docker/overlay2/89c41362f5bede23e58e1948df67dacb2f8e031738832630a5e901aa7db4febd/diff:/var/lib/docker/overlay2/e9bd3cf19ea6af9590a6df09abca75acb5f7634ded95df79bb158a6d216943a6/diff:/var/lib/docker/overlay2/ebc2a477d8c9ac070ea5de37099f3b80efd0698d7fbf5811fca26bc54aa8f07e/diff:/var/lib/docker/overlay2/2894154e23dc421fba917ea9eb787edb1aee511360524b97a870fdb12cb33f78/diff:/var/lib/docker/overlay2/c99c30315707466ccb756e6b5ba3270d3e7874c8c0d8172b06395678db137eff/diff",
        "MergedDir": "/var/lib/docker/overlay2/fe95bb65ff08221b1a55dfef103051685569e7d28b7c37acd1bad636a40b41b0/merged",
        "UpperDir": "/var/lib/docker/overlay2/fe95bb65ff08221b1a55dfef103051685569e7d28b7c37acd1bad636a40b41b0/diff",
        "WorkDir": "/var/lib/docker/overlay2/fe95bb65ff08221b1a55dfef103051685569e7d28b7c37acd1bad636a40b41b0/work"
    },
    "Name": "overlay2"
}
[root@ramon ~]#

DockerFile

DokcerFile简介

DockerFile就是用来构建镜像的脚本文件。

构建步骤：

  1. 编写一个DockerFile文件
  2. docker build 构建一个镜像
  3. docker run 运行镜像

DockerFile语法

基础语法

  1. 每个保留关键字（指令）都是大写字母
  2. 执行从上到下顺序执行
  3. 注释使用#
  4. 每个指令都会创建一个新的镜像层

Dokcer指令

DokcerFile命令

（图片来源于网络）

1
2
3
4
5
6
7
8
9
10
11
12
FROM             # 选择使用的基础镜像
MAINTAINER       # 镜像的所属人，姓名+邮箱
RUN              # 镜像构建的时候运行的命令
ADD              # 添加压缩文件
WORKDIR          # 镜像的工作目录
VOLUME           # 选择挂载的目录
EXPORT           # 选择暴露的端口
CMD              # 镜像启动时候运行的命令
ENTRYPOINR       # 追加命令
ONBUILD          # 当构建一个被继承DockerFile的时候会运行ONBUILD指令
COPY             # 类似于ADD，将文件cp到镜像中
ENV              # 构建的时候设置环境变量

构建命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
docker build
# 使用这个命令将我们编写的DockerFile文件构建成镜像
# 选项
[root@ramon ~]# docker build --help
Usage:  docker build [OPTIONS] PATH | URL | -
Build an image from a Dockerfile
Options:
      --add-host list           Add a custom host-to-IP mapping (host:ip)
      --build-arg list          Set build-time variables
      --cache-from strings      Images to consider as cache sources
      --cgroup-parent string    Optional parent cgroup for the container
      --compress                Compress the build context using gzip
      --cpu-period int          Limit the CPU CFS (Completely Fair Scheduler) period
      --cpu-quota int           Limit the CPU CFS (Completely Fair Scheduler) quota
  -c, --cpu-shares int          CPU shares (relative weight)
      --cpuset-cpus string      CPUs in which to allow execution (0-3, 0,1)
      --cpuset-mems string      MEMs in which to allow execution (0-3, 0,1)
      --disable-content-trust   Skip image verification (default true)
  -f, --file string             Name of the Dockerfile (Default is 'PATH/Dockerfile')
      --force-rm                Always remove intermediate containers
      --iidfile string          Write the image ID to the file
      --isolation string        Container isolation technology
      --label list              Set metadata for an image
  -m, --memory bytes            Memory limit
      --memory-swap bytes       Swap limit equal to memory plus swap: '-1' to enable unlimited swap
      --network string          Set the networking mode for the RUN instructions during build (default "default")
      --no-cache                Do not use cache when building the image
  -o, --output stringArray      Output destination (format: type=local,dest=path)
      --platform string         Set platform if server is multi-platform capable
      --progress string         Set type of progress output (auto, plain, tty). Use plain to show container output (default "auto")
      --pull                    Always attempt to pull a newer version of the image
  -q, --quiet                   Suppress the build output and print image ID on success
      --rm                      Remove intermediate containers after a successful build (default true)
      --secret stringArray      Secret file to expose to the build (only if BuildKit enabled): id=mysecret,src=/local/secret
      --security-opt strings    Security options
      --shm-size bytes          Size of /dev/shm
      --squash                  Squash newly built layers into a single new layer
      --ssh stringArray         SSH agent socket or keys to expose to the build (only if BuildKit enabled) (format: default|<id>[=<socket>|<key>[,<key>]])
      --stream                  Stream attaches to server to negotiate build context
  -t, --tag list                Name and optionally a tag in the 'name:tag' format
      --target string           Set the target build stage to build.
      --ulimit ulimit           Ulimit options (default [])

DcokerFile实战

实战: 制作一个自己centos镜像

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
# 目标：对原有centos镜像安装vim与net-tools工具（练手）
# 1. 编写DockerFile
[root@ramon dockerFile]# cat myDokerFile-centos
FROM centos
MAINTAINER ramon.zhang<zhanggewuang@163.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH

RUN yum -y install vim
RUN yum -y install net-tools

EXPOSE 80

CMD echo $MYPATH
CMD echo "---------end--------"
CMD /bin/bash
# 2. 运行DokcerFile
[root@ramon dockerFile]# docker build -f myDokerFile-centos -t mycentos:1.0 .
Sending build context to Docker daemon  2.048kB
Step 1/10 : FROM centos
 ---> 470671670cac
Step 2/10 : MAINTAINER ramon.zhang<zhanggewuang@163.com>
 ---> Running in 411d83255bcf
Removing intermediate container 411d83255bcf
 ---> 9784f18aa99d
Step 3/10 : ENV MYPATH /usr/local
 ---> Running in 448bf9c8a1c6
Removing intermediate container 448bf9c8a1c6
 ---> 2370c7623e1d
Step 4/10 : WORKDIR $MYPATH
 ---> Running in df9477d9c2dd
Removing intermediate container df9477d9c2dd
 ---> 49e9ed409b79
Step 5/10 : RUN yum -y install vim
 ---> Running in 60e92f52553a
Complete!
Removing intermediate container 60e92f52553a
 ---> ab13cfaaaf53
Step 6/10 : RUN yum -y install net-tools
 ---> Running in c3a91197c76d
Complete!
Removing intermediate container c3a91197c76d
 ---> b2631ab995f0
Step 7/10 : EXPOSE 80
 ---> Running in 3f04bcfb6b67
Removing intermediate container 3f04bcfb6b67
 ---> 2b8a96f7b45a
Step 8/10 : CMD echo $MYPATH
 ---> Running in fdbac1b75f7b
Removing intermediate container fdbac1b75f7b
 ---> e22806a8d89f
Step 9/10 : CMD echo "---------end--------"
 ---> Running in 770eab6701e5
Removing intermediate container 770eab6701e5
 ---> a823e7f6eab1
Step 10/10 : CMD /bin/bash
 ---> Running in abce817f4737
Removing intermediate container abce817f4737
 ---> 0eeb948069c8
Successfully built 0eeb948069c8
Successfully tagged mycentos:1.0
# 3. 查看结果
[root@ramon dockerFile]# docker images
REPOSITORY            TAG                 IMAGE ID            CREATED             SIZE
mycentos              1.0                 0eeb948069c8        3 minutes ago       317MB
ramon_tomcat          1.0                 667e7f63a6e3        23 hours ago        652MB
tomcat                latest              2eb5a120304e        11 days ago         647MB
nginx                 latest              2622e6cca7eb        11 days ago         132MB
# 4. 运行镜像，检验安装结果
[root@ramon dockerFile]# docker run -it mycentos:1.0
[root@b3aa682e447e local]# pwd
/usr/local
[root@0c3f15e416d2 local]# ifconfig
eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 172.17.0.5  netmask 255.255.0.0  broadcast 172.17.255.255
        ether 02:42:ac:11:00:05  txqueuelen 0  (Ethernet)
        RX packets 0  bytes 0 (0.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
        inet 127.0.0.1  netmask 255.0.0.0
        loop  txqueuelen 1000  (Local Loopback)
        RX packets 0  bytes 0 (0.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
[root@b3aa682e447e local]# exit
exit
# 5. 查看镜像的运行过程（见下图）

Dokerfile history

镜像发布

发布到DockerHub

步骤：

  1. 在官网注册账号
  2. 确认账号可以登录
  3. 在服务器登录账号docker login
  4. 提交镜像docker push
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 这里记得创建一个新的带上你id的镜像存储库
[root@ramon ~]# docker tag 0eeb948069c8 gewuang/mycentos:1.0
[root@ramon ~]# docker images
REPOSITORY            TAG                 IMAGE ID            CREATED             SIZE
mycentos              1.0                 0eeb948069c8        40 minutes ago      317MB
gewuang/mycentos      1.0                 0eeb948069c8        40 minutes ago      317MB
ramon_tomcat          1.0                 667e7f63a6e3        24 hours ago        652MB
tomcat                latest              2eb5a120304e        11 days ago         647MB
nginx                 latest              2622e6cca7eb        11 days ago         132MB
mysql                 latest              be0dbf01a0f3        12 days ago         541MB
portainer/portainer   latest              cd645f5a4769        2 weeks ago         79.1MB
centos                latest              470671670cac        5 months ago        237MB
hello-world           latest              bf756fb1ae65        5 months ago        13.3kB
[root@ramon ~]# docker push gewuang/mycentos:1.0
The push refers to repository [docker.io/gewuang/mycentos]
9fb18a809cb9: Pushing [========>                                          ]  3.946MB/22.79MB
b753bc072571: Pushing [======>                                            ]  7.604MB/57.21MB
0683de282177: Pushing [=>                                                 ]  7.102MB/237.1MB

这个是外网，可能有点慢或者连不上，可以选择阿里云的镜像仓库，具体操作阿里云文档写的很全面了，这里就不介绍了。

对了，退出账号的话使用docker logout就可以了。

参考文献

狂神B站Docker视频

Docker技术原理之Linux UnionFS

DokcerFile详解

-------------本文结束，感谢您的阅读-------------