docker学习笔记


阅读数: 次   

docker学习笔记

Docker 使用 Google 公司推出的 Go 语言 进行开发实现。
docker是linux容器的一种封装，提供简单易用的容器使用接口。它是最流行的Linux容器解决方案。
docker的接口相当简单，用户可以方便的创建、销毁容器。
docker将应用程序与程序的依赖，打包在一个文件里面。运行这个文件就会生成一个虚拟容器。
程序运行在虚拟容器里，如同在真实物理机上运行一样，有了docker，就不用担心环境问题了。

为何用docker

由于物理机的诸多问题，后来出现了虚拟机 但是虚拟化也是有局限性的，每一个虚拟机都是一个完整的操作系统，要分配系统资源，虚拟机多道一定程度时，操作系统本身资源也就消耗殆尽，或者说必须扩容

docker VS 传统虚拟机

如何解决环境配置的问题?

解决方案一 虚拟机

虚拟机也可以制作模板，基于模板创建虚拟机，保证环境问题一致

虚拟机（virtual machine）就是带环境安装的一种解决方案。它可以在一种操作系统里面运行另一种操作系统，比如在 Windows 系统里面运行 Linux 系统。应用程序对此毫无感知，因为虚拟机看上去跟真实系统一模一样，而对于底层系统来说，虚拟机就是一个普通文件，不需要了就删掉，对其他部分毫无影响。

虽然用户可以通过虚拟机还原软件的原始环境。但是，这个方案有几个缺点。

（1）资源占用多

虚拟机会独占一部分内存和硬盘空间。它运行的时候，其他程序就不能使用这些资源了。哪怕虚拟机里面的应用程序，真正使用的内存只有 1MB，虚拟机依然需要几百 MB 的内存才能运行。

（2）冗余步骤多

虚拟机是完整的操作系统，一些系统级别的操作步骤，往往无法跳过，比如用户登录。

（3）启动慢

启动操作系统需要多久，启动虚拟机就需要多久。可能要等几分钟，应用程序才能真正运行。
虚拟机的优点：
资源池：一个物理机的优点分配到了很多不同的虚拟机里
很容易拓展： 加物理机器/加虚拟机
很容易云化： 阿里云，腾讯云

解决方案二

现在:自从用上docker容器后，可以实现开发、测试和生产环境的统一化和标准化。

镜像作为标准的交付件，可在开发、测试和生产环境上以容器来运行，最终实现三套环境上的应用以及运行所依赖内容的完全一致。

由于虚拟机的诸多问题，Linux发展出了另一种虚拟化技术：Linux容器（Linux Containers，缩写LXC）

Linux容器不是模拟一个完整的操作系统，而是对进程进行隔离。在正常进程的外面套了一个保护层，对于容器里面进程来说，它接触的资源都是虚拟的，从而实现和底层系统的隔离。

（1）启动快

容器里面的应用，直接就是底层系统的一个进程，而不是虚拟机内部的进程。所以，启动容器相当于启动本机的一个进程，而不是启动一个操作系统，速度就快很多。

（2）资源占用少

容器只占用需要的资源，不占用那些没有用到的资源；虚拟机由于是完整的操作系统，不可避免要占用所有资源。另外，多个容器可以共享资源，虚拟机都是独享资源。

（3）体积小

容器只要包含用到的组件即可，而虚拟机是整个操作系统的打包，所以容器文件比虚拟机文件要小很多。

总之，容器有点像轻量级的虚拟机，能够提供虚拟化的环境，但是成本开销小得多。

docker的优势

更高效的利用系统资源
由于容器不需要进行硬件虚拟以及运行完整操作系统等额外开销，Docker 对系统 资源的利用率更高。
无论是应用执行速度、内存损耗或者文件存储速度，都要比传 统虚拟机技术更高效。因此，相比虚拟机技术，一个相同配置的主机，往往可以运 行更多数量的应用。
更快速的启动时间
传统的虚拟机技术启动应用服务往往需要数分钟，而 Docker 容器应用，由于直接 运行于宿主内核，无需启动完整的操作系统，因此可以做到秒级、甚至毫秒级的启 动时间。大大的节约了开发、测试、部署的时间。
一致的运行环境
开发过程中一个常见的问题是环境一致性问题。由于开发环境、测试环境、生产环 境不一致，导致有些 bug 并未在开发过程中被发现。
而 Docker 的镜像提供了除内 核外完整的运行时环境，确保了应用运行环境一致性，从而不会再出现 “这段代码 在我机器上没问题啊” 这类问题。

持续交付和部署
对开发和运维(DevOps)人员来说，最希望的就是一次创建或配置，可以在任意 地方正常运行。
使用 Docker 可以通过定制应用镜像来实现持续集成、持续交付、部署。开发人员 可以通过 Dockerfile 来进行镜像构建，并结合 持续集成(Continuous Integration) 系 统进行集成测试，
而运维人员则可以直接在生产环境中快速部署该镜像，甚至结合 持续部署(Continuous Delivery/Deployment) 系统进行自动部署。
而且使用 Dockerfile 使镜像构建透明化，不仅仅开发团队可以理解应用运行环 境，也方便运维团队理解应用运行所需条件，帮助更好的生产环境中部署该镜像。

更轻松的迁移
由于 Docker 确保了执行环境的一致性，使得应用的迁移更加容易。Docker 可以在 很多平台上运行，无论是物理机、虚拟机、公有云、私有云，甚至是笔记本，其运 行结果是一致的。
因此用户可以很轻易的将在一个平台上运行的应用，迁移到另一 个平台上，而不用担心运行环境的变化导致应用无法正常运行的情况。

docker三大概念

1
2
3
4
5
容器三大基本概念  
镜像 image  
容器 container  
仓库 repository  
docker整个生命周期就是这三个概念。

docker镜像

1
2
3
4
Docker镜像就是一个只读的模板。
例如：一个镜像可以包含一个完整的CentOS操作系统环境，里面仅安装了Apache或用户需要的其他应用程序。
镜像可以用来创建Docker容器。
Docker提供了一个很简单的机制来创建镜像或者更新现有的镜像，用户甚至可以直接从其他人那里下载一个已经做好的镜像来直接使用。

image的分层存储

1
2
因为镜像包含完整的root文件系统，体积是非常庞大的，因此docker在设计时按照Union FS的技术，将其设计为分层存储的架构。
镜像不是ISO那种完整的打包文件，镜像只是一个虚拟的概念，他不是一个完整的文件，而是由一组文件组成，或者多组文件系统联合组成。

docker容器(container)

1
2
3
4
5
6
image和container的关系，就像面向对象程序设计中的 类和实例一样，镜像是静态的定义（class），容器是镜像运行时的实体（object）。
容器可以被创建、启动、停止、删除、暂停
Docker利用容器来运行应用。
容器是从镜像创建的运行实例。它可以被启动、开始、停止、删除。每个容器都是相互隔离的，保证安全的平台。
可以把容器看做是一个简易版的Linux环境（包括root用户权限、进程空间、用户空间和网络空间等）和运行在其中的应用程序。
注意：镜像是只读的，容器在启动的时候创建一层可写层作为最上层。

docker仓库(repository)

1
2
3
4
5
仓库是集中存放镜像文件的场所。有时候把仓库和仓库注册服务器（Registry）混为一谈，并不严格区分。实际上，仓库注册服务器上往往存放着多个仓库，每个仓库中又包含了多个镜像，每个镜像有不同的标签(tag)。
仓库分为公开仓库(Public)和私有仓库(Private)两种形式。
最大的公开仓库是Docker Hub，存放了数量庞大的镜像供用户下载。国内的公开仓库包括Docker Pool等，可以提供大陆用户更稳定快读的访问。
当用户创建了自己的镜像之后就可以使用push命令将它上传到公有或者私有仓库，这样下载在另外一台机器上使用这个镜像时候，只需需要从仓库上pull下来就可以了。
注意：Docker仓库的概念跟Git类似，注册服务器可以理解为GitHub这样的托管服务。

docker Registry构建仓库

1
2
3
4
5
6
7
Docker Registry 公开服务是开放给用户使用、允许用户管理镜像的 Registry 服 务。一般这类公开服务允许用户免费上传、下载公开的镜像，并可能提供收费服务 供用户管理私有镜像。
最常使用的 Registry 公开服务是官方的 Docker Hub，这也是默认的 Registry，并 拥有大量的高质量的官方镜像。
除此以外，还有 CoreOS 的 Quay.io，CoreOS 相 关的镜像存储在这里;Google 的 Google Container Registry，Kubernetes 的镜像 使用的就是这个服务。
由于某些原因，在国内访问这些服务可能会比较慢。
国内的一些云服务商提供了针 对 Docker Hub 的镜像服务(Registry Mirror)，这些镜像服务被称为加速器。常见 的有 阿里云加速器、DaoCloud 加速器、灵雀云加速器等。
使用加速器会直接从国内的地址下载 Docker Hub 的镜像，比直接从官方网站下载速度会提高很多。在后 面的章节中会有进一步如何配置加速器的讲解。
国内也有一些云服务商提供类似于 Docker Hub 的公开服务。比如 时速云镜像仓 库、网易云镜像服务、DaoCloud 镜像市场、阿里云镜像库等。

安装配置docker

CentOS安装docker

官方教程：
https://docs.docker.com/engine/install/centos/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
1.卸载旧版本
sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-selinux \
                  docker-engine-selinux \
                  docker-engine
2.设置存储库
sudo yum install -y yum-utils \
  device-mapper-persistent-data \
  lvm2
sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo
3.安装docker社区版
sudo yum install docker-ce
4.启动关闭docker
systemctl start docker

系统环境准备
docker最低支持centos7且在64位平台上，内核版本在3.10以上

1
2
[root@oldboy_python ~ 10:48:11]#uname -r
3.10.0-693.el7.x86_64

踩坑：执行docker run hello-world时出现timeout的解决办法

1
2
3
4
[root@localhost un1queyan]# docker run hello-world
Unable to find image 'hello-world:latest' locally
docker: Error response from daemon: Get "https://registry-1.docker.io/v2/": net/http: request canceled while waiting for connection (Client.Timeout exceeded while awaiting headers).
See 'docker run --help'.

在配置了阿里云镜像，挂梯子等方法都不起作用后，在更改虚拟机的DNS后成功执行

1
[root@localhost un1queyan]# sudo vim /etc/resolv.conf

将namespace改为8.8.8.8

1
2
3
4
# Generated by NetworkManager
search localdomain
nameserver 8.8.8.8
~

执行docker run hello-world

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

docker hello-world 执行成功！

踩坑2：dockerfile中yum卡住

告警：ip转发功能未打开，网络将无法生效

1
2
echo 'net.ipv4.ip_forward=1' >> /etc/sysctl.conf`
`sysctl -p

Run的执行流程和docker执行原理

Run的执行流程

image-20211009192327681

底层原理

docker是怎样工作的

Docker是一个client-server结构的系统，Docker的守护进程运行在主机上。通过socket客户端访问

DockerServer接收到Docker-Client指令，就会执行这个命令。

image-20211009193148765

Docker为什么比VM快

1、 Docker有比虚拟机更少的抽象层

2、 docker利用的是宿主机的内核， VM需要的是Guest OS

image-20211009193408017

所以说，新建一个容器的时候，docker不需要像虚拟机一样重新加载一个操作系统的内核，避免引导，虚拟机加载的是 Guest OS， 分钟级别的， 而docker利用的是宿主机的操作系统，省略了这个复杂的过程， 秒级

image-20211009193614226

docker的常用命令

帮助命令

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
[root@docker ~]# docker --help  # 万能命令
Usage:
docker [OPTIONS] COMMAND [arg...]
       docker daemon [ --help | ... ]
       docker [ --help | -v | --version ]
A
self-sufficient runtime for containers.
Options:
  --config=~/.docker              Location of client config files  #客户端配置文件的位置
  -D, --debug=false               Enable debug mode  #启用Debug调试模式
  -H, --host=[]                   Daemon socket(s) to connect to  #守护进程的套接字（Socket）连接
  -h, --help=false                Print usage  #打印使用
  -l, --log-level=info            Set the logging level  #设置日志级别
  --tls=false                     Use TLS; implied by--tlsverify  #
  --tlscacert=~/.docker/ca.pem    Trust certs signed only by this CA  #信任证书签名CA
  --tlscert=~/.docker/cert.pem    Path to TLS certificate file  #TLS证书文件路径
  --tlskey=~/.docker/key.pem      Path to TLS key file  #TLS密钥文件路径
  --tlsverify=false               Use TLS and verify the remote  #使用TLS验证远程
  -v, --version=false             Print version information and quit  #打印版本信息并退出
Commands:
    attach    Attach to a running container  #当前shell下attach连接指定运行镜像
    build     Build an image from a Dockerfile  #通过Dockerfile定制镜像
    commit    Create a new image from a container's changes  #提交当前容器为新的镜像
    cp    Copy files/folders from a container to a HOSTDIR or to STDOUT  #从容器中拷贝指定文件或者目录到宿主机中
    create    Create a new container  #创建一个新的容器，同run 但不启动容器
    diff    Inspect changes on a container's filesystem  #查看docker容器变化
    events    Get real time events from the server#从docker服务获取容器实时事件
    exec    Run a command in a running container#在已存在的容器上运行命令
    export    Export a container's filesystem as a tar archive  #导出容器的内容流作为一个tar归档文件(对应import)
    history    Show the history of an image  #展示一个镜像形成历史
    images    List images  #列出系统当前镜像
    import    Import the contents from a tarball to create a filesystem image  #从tar包中的内容创建一个新的文件系统映像(对应export)
    info    Display system-wide information  #显示系统相关信息
    inspect    Return low-level information on a container or image  #查看容器详细信息
    kill    Kill a running container  #kill指定docker容器
    load    Load an image from a tar archive or STDIN  #从一个tar包中加载一个镜像(对应save)
    login    Register or log in to a Docker registry#注册或者登陆一个docker源服务器
    logout    Log out from a Docker registry  #从当前Docker registry退出
    logs    Fetch the logs of a container  #输出当前容器日志信息
    pause    Pause all processes within a container#暂停容器
    port    List port mappings or a specific mapping for the CONTAINER  #查看映射端口对应的容器内部源端口
    ps    List containers  #列出容器列表
    pull    Pull an image or a repository from a registry  #从docker镜像源服务器拉取指定镜像或者库镜像
    push    Push an image or a repository to a registry  #推送指定镜像或者库镜像至docker源服务器
    rename    Rename a container  #重命名容器
    restart    Restart a running container  #重启运行的容器
    rm    Remove one or more containers  #移除一个或者多个容器
    rmi    Remove one or more images  #移除一个或多个镜像(无容器使用该镜像才可以删除，否则需要删除相关容器才可以继续或者-f强制删除)
    run    Run a command in a new container  #创建一个新的容器并运行一个命令
    save    Save an image(s) to a tar archive#保存一个镜像为一个tar包(对应load)
    search    Search the Docker Hub for images  #在docker
hub中搜索镜像
    start    Start one or more stopped containers#启动容器
    stats    Display a live stream of container(s) resource usage statistics  #统计容器使用资源
    stop    Stop a running container  #停止容器
    tag         Tag an image into a repository  #给源中镜像打标签
    top       Display the running processes of a container #查看容器中运行的进程信息
    unpause    Unpause all processes within a container  #取消暂停容器
    version    Show the Docker version information#查看容器版本号
    wait         Block until a container stops, then print its exit code  #截取容器停止时的退出状态值
Run 'docker COMMAND --help' for more information on a command.  #运行docker命令在帮助可以获取更多信息

1
2
3
docker version        # 显示docker的版本信息
docker info           # 显示docker的系统信息， 包括镜像和容器的数量
docker --help         # 帮助命令

镜像命令

docker images查看所有本地主机上的镜像

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
[root@localhost un1queyan]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
hello-world   latest    feb5d9fea6a5   2 weeks ago     13.3kB
centos        latest    300e315adb2f   10 months ago   209MB

# 解释 
REPOSITORY   镜像的仓库源
TAG          镜像的标签
IMAGE ID     镜像的id
CREATED      镜像的创建时间zhixiangshi
SIZE         镜像的大小

#  可选项
  -a, --all      # 列出所有的镜像
  -q, --quiet    # 只显示镜像的id

docker search搜索镜像

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
[root@localhost un1queyan]# docker search mysql
NAME                              DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql                             MySQL is a widely used, open-source relation…   11516     [OK]       
mariadb                           MariaDB Server is a high performing open sou…   4369      [OK]       
mysql/mysql-server                Optimized MySQL Server Docker images. Create…   851                  [OK]
centos/mysql-57-centos7           MySQL 5.7 SQL database server                   91                   
mysql/mysql-cluster               Experimental MySQL Cluster Docker images. Cr…   88                   
centurylink/mysql                 Image containing mysql. Optimized to be link…   59                   [OK]

# 可选项， 通过收藏过滤
 --filter=STARS=3000     # 搜索出的镜像是关注数大于3000的
[root@localhost un1queyan]# docker search mysql --filter=STARS=3000
NAME      DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql     MySQL is a widely used, open-source relation…   11516     [OK]       
mariadb   MariaDB Server is a high performing open sou…   4369      [OK]

docker pull拉取镜像

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
# 下载镜像 docker pull 镜像名[:tag]
[root@localhost un1queyan]# docker pull mysql
Using default tag: latest   # 如果不写tag， 默认就是lastest
latest: Pulling from library/mysql
07aded7c29c6: Pull complete     # 分层下载，docker image的核心 联合文件系统
f68b8cbd22de: Pull complete 
30c1754a28c4: Pull complete 
1b7cb4d6fe05: Pull complete 
79a41dc56b9a: Pull complete 
00a75e3842fb: Pull complete 
b36a6919c217: Pull complete 
635b0b84d686: Pull complete 
6d24c7242d02: Pull complete 
5be6c5edf16f: Pull complete 
cb35eac1242c: Pull complete 
a573d4e1c407: Pull complete 
Digest: sha256:4fcf5df6c46c80db19675a5c067e737c1bc8b0e78e94e816a778ae2c6577213d
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest    # 真实地址

# 等价于
docker pull mysql     
docker pull docker.io/library/mysql:latest

[root@localhost un1queyan]# docker pull mysql:5.7
5.7: Pulling from library/mysql
07aded7c29c6: Already exists     # 已经存在无需重复下载
f68b8cbd22de: Already exists 
30c1754a28c4: Already exists 
1b7cb4d6fe05: Already exists 
79a41dc56b9a: Already exists 
00a75e3842fb: Already exists 
b36a6919c217: Already exists 
5e11fe494f45: Pull complete      
9c7de1f889a7: Pull complete 
cf6a13d05a76: Pull complete 
fc5aa81f393a: Pull complete 
Digest: sha256:360c7488c2b5d112804a74cd272d1070d264eef4812d9a9cc6b8ed68c3546189
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7

# 根据id删除镜像
[root@localhost un1queyan]#  docker rmi -f 9f35042c6a98

# 删除多个镜像
[root@localhost un1queyan]#  docker rmi -f 镜像id 镜像id 镜像id 镜像id

# 删除所有镜像
[root@localhost un1queyan]#  docker rmi -f $(docker images -aq)


容器命令

说明： 我们有了镜像才可以创建容器，linux， 下载一个centos镜像来测试学习

1
[root@localhost un1queyan]# docker pull 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
docker run [可选参数] image

# 参数说明
--name="Name"    # 容器名字  tomcat01   tomcat02， 用来区分容器
-d               # 后台方式运行
-it              # 使用交互方式运行， 进入容器查看内容
-p               # 指定容器的端口  -p   8080：8080
	-p ip: 主机端口：容器端口
	-p 主机端口：容器端口 （常用）
	-p 容器端口
	容器端口
-p               # 随机指定端口

# 测试， 启动并进入容器
[root@localhost un1queyan]# docker run -it centos /bin/bash
[root@8b5255b5ae5d /]# ls    # 查看容器内的centos，基础版本，很多命令都是不完善的
bin  etc   lib	  lost+found  mnt  proc  run   srv  tmp  var
dev  home  lib64  media       opt  root  sbin  sys  usr

# 从容器中退出到主机
[root@8b5255b5ae5d /]# exit
exit
[root@localhost un1queyan]# ls
erlang-solutions-2.0-1.noarch.rpm  Python-3.6.7.tar                         模板  下载
nginx-1.12.0                       Python-3.6.7.tar.xz.1                    视频  音乐
nginx-1.12.0.tar.gz                rabbitmq-server-3.8.13-1.el8.noarch.rpm  图片  桌面
Python-3.6.7                       公共                                     文档


列出所有的运行的容器

1
2
3
4
5
6
7
8
9
10
11
# docker ps 命令
-a    # 列出当前正在运行的容器 + 未运行的容器
-n=？  # 显示最近创建的容器
-q    # 只显示容器的编号
[root@localhost un1queyan]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
[root@localhost un1queyan]# docker ps -a
CONTAINER ID   IMAGE          COMMAND       CREATED         STATUS                     PORTS     NAMES
8b5255b5ae5d   centos         "/bin/bash"   5 minutes ago   Exited (0) 2 minutes ago             upbeat_germain
ab64a059833f   feb5d9fea6a5   "/hello"      5 hours ago     Exited (0) 5 hours ago               sharp_saha
57a5d0761f1b   feb5d9fea6a5   "/hello"      5 hours ago     Exited (0) 5 hours ago               busy_hypatia

退出容器

1
2
3
4
5
6
7
8
9
exit    # 直接容器停止并退出
Ctrl + P + Q	# 容器不停止退出

[root@localhost un1queyan]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
[root@localhost un1queyan]# docker run -it centos /bin/bash
[root@9fe6982ec39d /]# [root@localhost un1queyan]# docker ps
CONTAINER ID   IMAGE     COMMAND       CREATED          STATUS          PORTS     NAMES
9fe6982ec39d   centos    "/bin/bash"   29 seconds ago   Up 28 seconds             gracious_jemison

删除容器

1
2
3
docker rm 容器id，                   # 删除指定的容器，不能删除正在运行的容器
docker rm -f $(docker ps -aq) 		# 删除所有的容器
docker ps -a -q|xargs docker rm		# 删除所有的容器

启动和停止容器的操作

1
2
3
4
5
docker start 容器id		# 启动容器
docker restart 容器id		# 重启容器
docker stop 容器id		# 停止当前正在运行的容器
docker kill 容器id		# 强制停止当前容器

常用其他命令

后台启动容器

1
2
3
4
5
6
7
# 命令docker run -d 镜像名！
[root@localhost un1queyan]# docker run -d centos

# 问题docker ps， 发现centos 停止了

# 常见的坑： docker容器使用后台运行，就必须要有一个前台进程，docker发现没有应用，就会自动停止  
# nginx，容器启动后，发现自己没有提供服务，就会立刻停止，就是没有程序了

查看日志

1
2
3
4
5
6
7
8
9
10
11
12
13
docker logs -f -t --tail 容器

# 自己写一段shell脚本 
[root@localhost un1queyan]# docker run -d centos /bin/bash -c "while true;do echo un1queyan;sleep 1;done"

[root@localhost un1queyan]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS        PORTS     NAMES
80d7d260d55f   centos    "/bin/bash -c 'while…"   2 seconds ago   Up 1 second             brave_sammet

# 显示日志
 -tf					# 显示日志
 --tail number			# 要显示日志条数
[root@localhost un1queyan]# docker logs -tf --tail 10 80d7d260d55f

查看容器中进程信息

1
2
3
4
# 命令 docker top 容器 id
[root@localhost un1queyan]# docker top 0f3140f21fcb
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                18570               18551               0                   05:30               pts/0               00:00:00            /bin/bash

查看镜像的元数据

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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
[root@localhost un1queyan]# docker inspect [root@localhost un1queyan]# docker top 0f3140f21fcb
[
    {
        "Id": "0f3140f21fcbb9e5b31dad7f3a473685cd788eb2e19d435c15aa963ec4e5964c",
        "Created": "2021-10-09T21:30:44.61713145Z",
        "Path": "/bin/bash",
        "Args": [],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 18570,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2021-10-09T21:30:45.248080254Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:5d0da3dc976460b72c77d94c8a1ad043720b0416bfc16c52c45d4847e53fadb6",
        "ResolvConfPath": "/var/lib/docker/containers/0f3140f21fcbb9e5b31dad7f3a473685cd788eb2e19d435c15aa963ec4e5964c/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/0f3140f21fcbb9e5b31dad7f3a473685cd788eb2e19d435c15aa963ec4e5964c/hostname",
        "HostsPath": "/var/lib/docker/containers/0f3140f21fcbb9e5b31dad7f3a473685cd788eb2e19d435c15aa963ec4e5964c/hosts",
        "LogPath": "/var/lib/docker/containers/0f3140f21fcbb9e5b31dad7f3a473685cd788eb2e19d435c15aa963ec4e5964c/0f3140f21fcbb9e5b31dad7f3a473685cd788eb2e19d435c15aa963ec4e5964c-json.log",
        "Name": "/gallant_shtern",
        "RestartCount": 0,
        "Driver": "overlay2",
        "Platform": "linux",
        "MountLabel": "",
        "ProcessLabel": "",
        "AppArmorProfile": "",
        "ExecIDs": null,
        "HostConfig": {
            "Binds": null,
            "ContainerIDFile": "",
            "LogConfig": {
                "Type": "json-file",
                "Config": {}
            },
            "NetworkMode": "default",
            "PortBindings": {},
            "RestartPolicy": {
                "Name": "no",
                "MaximumRetryCount": 0
            },
            "AutoRemove": false,
            "VolumeDriver": "",
            "VolumesFrom": null,
            "CapAdd": null,
            "CapDrop": null,
            "CgroupnsMode": "host",
            "Dns": [],
            "DnsOptions": [],
            "DnsSearch": [],
            "ExtraHosts": null,
            "GroupAdd": null,
            "IpcMode": "private",
            "Cgroup": "",
            "Links": null,
            "OomScoreAdj": 0,
            "PidMode": "",
            "Privileged": false,
            "PublishAllPorts": false,
            "ReadonlyRootfs": false,
            "SecurityOpt": null,
            "UTSMode": "",
            "UsernsMode": "",
            "ShmSize": 67108864,
            "Runtime": "runc",
            "ConsoleSize": [
                0,
                0
            ],
            "Isolation": "",
            "CpuShares": 0,
            "Memory": 0,
            "NanoCpus": 0,
            "CgroupParent": "",
            "BlkioWeight": 0,
            "BlkioWeightDevice": [],
            "BlkioDeviceReadBps": null,
            "BlkioDeviceWriteBps": null,
            "BlkioDeviceReadIOps": null,
            "BlkioDeviceWriteIOps": null,
            "CpuPeriod": 0,
            "CpuQuota": 0,
            "CpuRealtimePeriod": 0,
            "CpuRealtimeRuntime": 0,
            "CpusetCpus": "",
            "CpusetMems": "",
            "Devices": [],
            "DeviceCgroupRules": null,
            "DeviceRequests": null,
            "KernelMemory": 0,
            "KernelMemoryTCP": 0,
            "MemoryReservation": 0,
            "MemorySwap": 0,
            "MemorySwappiness": null,
            "OomKillDisable": false,
            "PidsLimit": null,
            "Ulimits": null,
            "CpuCount": 0,
            "CpuPercent": 0,
            "IOMaximumIOps": 0,
            "IOMaximumBandwidth": 0,
            "MaskedPaths": [
                "/proc/asound",
                "/proc/acpi",
                "/proc/kcore",
                "/proc/keys",
                "/proc/latency_stats",
                "/proc/timer_list",
                "/proc/timer_stats",
                "/proc/sched_debug",
                "/proc/scsi",
                "/sys/firmware"
            ],
            "ReadonlyPaths": [
                "/proc/bus",
                "/proc/fs",
                "/proc/irq",
                "/proc/sys",
                "/proc/sysrq-trigger"
            ]
        },
        "GraphDriver": {
            "Data": {
                "LowerDir": "/var/lib/docker/overlay2/55bbe0b3ee92371e0e50cc5aaa73e6490860de566cefc311e1b5ee03143a161b-init/diff:/var/lib/docker/overlay2/7ef4880388278869d7ef76a7f3214b88f1a14c85229548c039235248851a95e4/diff",
                "MergedDir": "/var/lib/docker/overlay2/55bbe0b3ee92371e0e50cc5aaa73e6490860de566cefc311e1b5ee03143a161b/merged",
                "UpperDir": "/var/lib/docker/overlay2/55bbe0b3ee92371e0e50cc5aaa73e6490860de566cefc311e1b5ee03143a161b/diff",
                "WorkDir": "/var/lib/docker/overlay2/55bbe0b3ee92371e0e50cc5aaa73e6490860de566cefc311e1b5ee03143a161b/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "0f3140f21fcb",
            "Domainname": "",
            "User": "",
            "AttachStdin": true,
            "AttachStdout": true,
            "AttachStderr": true,
            "Tty": true,
            "OpenStdin": true,
            "StdinOnce": true,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
            ],
            "Cmd": [
                "/bin/bash"
            ],
            "Image": "centos",
            "Volumes": null,
            "WorkingDir": "",
            "Entrypoint": null,
            "OnBuild": null,
            "Labels": {
                "org.label-schema.build-date": "20210915",
                "org.label-schema.license": "GPLv2",
                "org.label-schema.name": "CentOS Base Image",
                "org.label-schema.schema-version": "1.0",
                "org.label-schema.vendor": "CentOS"
            }
        },
        "NetworkSettings": {
            "Bridge": "",
            "SandboxID": "d1b495058439ce2c0d444a46533fda485fd9795cc9ba5f2e7790bb33dff04a7d",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/d1b495058439",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "397f695b6a75668efd38bad430682175bb95de38debd2bf37acd551abd76abce",
            "Gateway": "172.17.0.1",
            "GlobalIPv6Address": "",
            "GlobalIPv6PrefixLen": 0,
            "IPAddress": "172.17.0.2",
            "IPPrefixLen": 16,
            "IPv6Gateway": "",
            "MacAddress": "02:42:ac:11:00:02",
            "Networks": {
                "bridge": {
                    "IPAMConfig": null,
                    "Links": null,
                    "Aliases": null,
                    "NetworkID": "37b592d00ea75d598035cf80a14d05b1faa464ce07c9f7a4a2e85845e1ead2c6",
                    "EndpointID": "397f695b6a75668efd38bad430682175bb95de38debd2bf37acd551abd76abce",
                    "Gateway": "172.17.0.1",
                    "IPAddress": "172.17.0.2",
                    "IPPrefixLen": 16,
                    "IPv6Gateway": "",
                    "GlobalIPv6Address": "",
                    "GlobalIPv6PrefixLen": 0,
                    "MacAddress": "02:42:ac:11:00:02",
                    "DriverOpts": null
                }
            }
        }
    }
]

进入当前正在运行的容器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 我们通常容器都是使用后台方式运行的，需要进入容器，修改一些配置

# 命令 
docker exex -it 容器id bashshell
[root@localhost un1queyan]# docker ps
CONTAINER ID   IMAGE     COMMAND       CREATED          STATUS          PORTS     NAMES
0f3140f21fcb   centos    "/bin/bash"   35 minutes ago   Up 35 minutes             gallant_shtern
[root@localhost un1queyan]# docker exec -it 0f3140f21fcb /bin/bash
[root@0f3140f21fcb /]# ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 21:30 pts/0    00:00:00 /bin/bash
root        16     0  0 22:06 pts/1    00:00:00 /bin/bash
root        31    16  0 22:07 pts/1    00:00:00 ps -ef

# 方式二：
docker attach 容器id
[root@localhost un1queyan]# docker ps
CONTAINER ID   IMAGE     COMMAND       CREATED          STATUS          PORTS     NAMES
0f3140f21fcb   centos    "/bin/bash"   42 minutes ago   Up 42 minutes             gallant_shtern
[root@localhost un1queyan]# docker attach 0f3140f21fcb
[root@0f3140f21fcb /]# 

# docker exex		# 进入容器后开启一个新的终端， 可以在里面操作（常用）
# docker attach		# 进入容器正在执行的终端，不会启动新的进程

从容器内拷贝文件到主机上

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
docker cp 容器id：容器内路径  目的地主机路径
[root@iZwz99sm8v95sckz8bd2c4Z ~]# docker exec -it c703b5b1911f /bin/bash
[root@c703b5b1911f /]# cd home
[root@c703b5b1911f home]# ls
#touch 新建文件
[root@c703b5b1911f home]# touch test.java
[root@c703b5b1911f home]# ls
test.java
[root@c703b5b1911f home]# exit
exit
[root@iZwz99sm8v95sckz8bd2c4Z ~]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS          PORTS     NAMES
c703b5b1911f   centos    "/bin/sh -c 'while t…"   35 minutes ago   Up 35 minutes             pedantic_banach
[root@iZwz99sm8v95sckz8bd2c4Z ~]# docker cp c703b5b1911f:/home/test.java /home
[root@iZwz99sm8v95sckz8bd2c4Z ~]# ls /home
hai  pan  test.java

# 拷贝是一个手动的过程，未来我们使用-v卷的技术，可以实现自动同步

小结

image-20211009224225943

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
attach    Attach to a running container  #当前shell下attach连接指定运行镜像
build     Build an image from a Dockerfile  #通过Dockerfile定制镜像
commit    Create a new image from a containers changes  #提交当前容器为新的镜像
cp        Copy files/folders from a container to a HOSTDIR or to STDOUT  #从容器中拷贝指定文件或者目录到宿主机中
create    Create a new container  #创建一个新的容器，同run 但不启动容器
diff      Inspect changes on a containers filesystem  #查看docker容器变化
events    Get real time events from the server#从docker服务获取容器实时事件
exec      Run a command in a running container#在已存在的容器上运行命令
export    Export a containers filesystem as a tar archive  #导出容器的内容流作为一个tar归档文件(对应import)
history   Show the history of an image  #展示一个镜像形成历史
images    List images  #列出系统当前镜像
import    Import the contents from a tarball to create a filesystem image  #从tar包中的内容创建一个新的文件系统映像(对应export)
info      Display system-wide information  #显示系统相关信息
inspect   Return low-level information on a container or image  #查看容器详细信息
kill      Kill a running container  #kill指定docker容器
load      Load an image from a tar archive or STDIN  #从一个tar包中加载一个镜像(对应save)
login     Register or log in to a Docker registry#注册或者登陆一个docker源服务器
logout    Log out from a Docker registry  #从当前Docker registry退出
logs      Fetch the logs of a container  #输出当前容器日志信息
pause     Pause all processes within a container#暂停容器
port      List port mappings or a specific mapping for the CONTAINER  #查看映射端口对应的容器内部源端口
ps        List containers  #列出容器列表
pull      Pull an image or a repository from a registry  #从docker镜像源服务器拉取指定镜像或者库镜像
push      Push an image or a repository to a registry  #推送指定镜像或者库镜像至docker源服务器
rename    Rename a container  #重命名容器
restart   Restart a running container  #重启运行的容器
rm        Remove one or more containers  #移除一个或者多个容器
rmi       Remove one or more images  #移除一个或多个镜像(无容器使用该镜像才可以删除，否则需要删除相关容器才可以继续或者-f强制删除)
run       Run a command in a new container  #创建一个新的容器并运行一个命令
save      Save an image(s) to a tar archive#保存一个镜像为一个tar包(对应load)
search    Search the Docker Hub for images  #在docker
hub中搜索镜像
start     Start one or more stopped containers#启动容器
stats     Display a live stream of container(s) resource usage statistics  #统计容器使用资源
stop      Stop a running container  #停止容器
tag       Tag an image into a repository  #给源中镜像打标签
top       Display the running processes of a container #查看容器中运行的进程信息
unpause   Unpause all processes within a container  #取消暂停容器
version   Show the Docker version information  #查看容器版本号
wait      Block until a container stops, then print its exit code  #截取容器停止时的退出状态值

部署nginx

docker 安装nginx

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
[root@localhost un1queyan]# docker images
REPOSITORY   TAG       IMAGE ID       CREATED       SIZE
nginx        latest    f8f4ffc8092c   12 days ago   133MB
centos       latest    5d0da3dc9764   3 weeks ago   231MB
[root@localhost un1queyan]# docker run -d --name nginx01 -p 3344:80 nginx
cd2541dbe2c0660df6d05062d56d5ea32dff8b6cdfb3d4799cf008f44e9ae88b
[root@localhost un1queyan]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS          PORTS                                   NAMES
cd2541dbe2c0   nginx     "/docker-entrypoint.…"   19 seconds ago   Up 18 seconds   0.0.0.0:3344->80/tcp, :::3344->80/tcp   nginx01
e0127375513e   centos    "/bin/bash"              18 hours ago     Up 18 hours                                             quirky_meitner
[root@localhost un1queyan]# curl localhost:3344

# 进入容器
[root@localhost un1queyan]# docker exec -it nginx01 /bin/bash
root@cd2541dbe2c0:/# whereis nginx
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx
root@cd2541dbe2c0:/# ls
bin   dev		   docker-entrypoint.sh  home  lib64  mnt  proc  run   srv  tmp  var
boot  docker-entrypoint.d  etc			 lib   media  opt  root  sbin  sys  usr
root@cd2541dbe2c0:/#

端口暴露的概念

image-20211011003559631

docker部署tomcat

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 官方的使用
docker run -it  --rm tomcat:9.0

# 我们之前的使用都是后台，停止了容器之后，容器还是可以查看到 docker run -it  --rm tomcat:9.0 一般用于测试 用完即删
[root@localhost un1queyan]# docker run -d -p 3355:8080 --name tomcat01 tomcat

# 进入容器
[root@localhost un1queyan]# docker exec -it tomcat01 /bin/bash
root@8453bcccc839:/usr/local/tomcat# ls
BUILDING.txt	 NOTICE		RUNNING.txt  lib	     temp	   work
CONTRIBUTING.md  README.md	bin	     logs	     webapps
LICENSE		 RELEASE-NOTES	conf	     native-jni-lib  webapps.dist
root@8453bcccc839:/usr/local/tomcat# cd webapps
root@8453bcccc839:/usr/local/tomcat/webapps# ls

# 发现问题： 1.linux命令少了 2.没有webapp 阿里云镜像的原因，默认是最小镜像
# 保证最小可运行的环境

docker stats 查看cpu的状态

可视化

  • portainer （先用这个）
1
2
docker run -d -p 8088:9000 \
--restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer
  • Rancher(CI/CD再用)

什么是portainer？

Docker图形化界面管理工具！提供一个后台面板供我们操作

1
2
docker run -d -p 8088:9000 \
--restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer

image-20211011113050615

image-20211011113615414

Docker镜像讲解

镜像是什么

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

所有的应用直接打包成docker文件就可以直接跑起来

如何得到镜像

  • 从远程仓库下载
  • 朋友拷贝
  • 自己制作一个dockerfile

Docker镜像原理

UnionFS(联合文件系统)
UnionFS(联合文件系统): Union文件系统(UnionFS)是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。Union文件系统是Docker镜像的基础。镜像可以通过分层来进行继承, 基于基础镜像(没有父镜像)， 可以制作各种具体的应用镜像。
特性: 一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录。

Docker镜像加载原理
docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS。

**bootfs(boot file system)**主要包含bootloader和kernel，bootloader主要是引导加载kernel，Linux刚启动时会加载bootfs文件系统，在Docker镜像的最底层是bootfs。这一层与我们典型的Linux/Unix系统是一样的, 包含boot加载器和内核。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。

rootfs(root file system), 在bootfs之上。包含的就是典型Linux系统中的/dev, /proc, /bin, /etc等标准目录和文件。rootfs就是各种不同的操作系统发行版，比如Ubuntu，Centos等等。

平时我们安装虚拟机的CentOS都是好几个G，为什么docker这里才200M？

对于一个精简的OS，rootfs可以很小，只需要包括最基本的命令、工具和程序库就可以了，因为底层直接用Host的kernel，自己只需要提供rootfs就行了。由此可见对于不同的linux发行版，bootfs基本是一致的，rootfs会有差别，因此不同的发行版可以共用bootfs。

分层的镜像
以我们的pull为例，在下载的过程中我们可以看到docker的镜像好像是在一层一层的在下载

为什么docker镜像要采用这种分层结构呢
最大的一个好吃就是共享资源
比如：有多个镜像都从相同的base镜像构建而来，那么宿主机只需在磁盘上保存一份base镜像,同时内存中也只需加载一份base镜像，就可以为所有容器服务了。而且镜像的每一层都可以被共享。

  1. 镜像的特点
    Docker镜像都是只读的
    当容器启动时，一个新的可写层被加载到镜像的顶部。
    这一层通常被称作为”容器层”，“容器层”之下的都叫”镜像层”。

commit镜像

1
2
3
4
docker commit 提交一个容器成为一个新的副本

# 命令和git原理类似
docker commit -m="提交的描述信息" -a="作者" 容器id 目标镜像名:[TAG]

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 启动一个默认的tomcat
[root@localhost un1queyan]# docker ps
CONTAINER ID   IMAGE     COMMAND             CREATED         STATUS         PORTS                                       NAMES
a178af2bd4c0   tomcat    "catalina.sh run"   9 minutes ago   Up 9 minutes   0.0.0.0:8080->8080/tcp, :::8080->8080/tcp   quizzical_einstein
[root@localhost un1queyan]# docker exec -it a178af2bd4c0 /bin/bash
root@a178af2bd4c0:/usr/local/tomcat# cd webapps

# 发现这个默认的tomcat是没有webapps应用， 镜像的原因，官方的镜像默认webapps下面是没有文件的
root@a178af2bd4c0:/usr/local/tomcat/webapps# ls
root@a178af2bd4c0:/usr/local/tomcat/webapps# cd ..
root@a178af2bd4c0:/usr/local/tomcat# ls
BUILDING.txt	 NOTICE		RUNNING.txt  lib	     temp	   work
CONTRIBUTING.md  README.md	bin	     logs	     webapps
LICENSE		 RELEASE-NOTES	conf	     native-jni-lib  webapps.dist

# 自己拷贝进去基本的文件
root@a178af2bd4c0:/usr/local/tomcat# cp -r webapps.dist/* webapps
root@a178af2bd4c0:/usr/local/tomcat# cd webapps
root@a178af2bd4c0:/usr/local/tomcat/webapps# ls
ROOT  docs  examples  host-manager  manager

# 将我们操作过的容器通过commit提交为一个镜像！我们以后就使用我们修改过的镜像即可，这就是我们自己的一个修改过的镜像

image-20211011200647926

容器数据卷

什么是容器数据卷

docker的理念回顾

将应用和环境打包成一个镜像

数据如果都在容器中，容器删除，数据丢失 需求：数据可以持久化

MySQL,容器删除，删库跑路。 需求：MySQL数据可以存储在本地

容器之间可以有一个数据共享的技术！docker容器内的目录，同步到本地

这就是卷技术！目录 挂载，将我们容器内的目录，挂载到linux上面！

使用数据卷

方式一：直接使用命令来挂载 -v

1
2
3
4
5
6
docker run -it -v 主机目录；容器内目录

# test
[root@localhost un1queyan]# docker run -it -v /home/ceshi:/home centos /bin/bash

# 启动起来时候我们可以通过docker inspect 容器id

image-20211011210614883

持久化mysql

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 获取镜像
[root@localhost un1queyan]# docker pull mysql:5.7

# 运行容器，需要做数据挂载！ # 安装启动mysql，需要配置密码的

# 启动mysql
-d 后台运行
-p 端口映射
-v 挂载卷
-e 环境配重
--name 容器名字
[root@localhost un1queyan]# docker run -d -p 3310:3306 -v /home/mysql/conf.d:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7

# 启动成功后，在我们本地使用 sqlyog来测试一下
# sqlyog-链接服务器端3310  --- 3310 和容器内的 3306映射

具名和匿名挂载

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 匿名挂载
-v 容器内路径
docker run -d -p --name nginx01 -v /etc/nginx nginx

# 查看所有的卷的情况
[root@localhost un1queyan]# docker volume ls
local     826c3f1b727ca4077ece894dbc213f2f21ce862dda325c9d63bc55ecc6a96b31

# 这里发现，这种就是匿名挂载

# 具名挂载
[root@localhost un1queyan]# docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx
4df6708bceaee9d4abf7729febc9b30a226c4405d09adcd66f26208f5fca5dff
[root@localhost un1queyan]# docker volume ls
DRIVER    VOLUME NAME
local     826c3f1b727ca4077ece894dbc213f2f21ce862dda325c9d63bc55ecc6a96b31
local     juming-nginx

# 通过 -v 卷名：容器内路径
# 查看一下这个卷

image-20211011230059892

所有docker容器内的卷，没有指定目录的情况下都是在 /var/lib/docker/volumes/juming-nginx/_data

1
2
3
4
5
6
7
[root@localhost un1queyan]# cd /var/lib/docker/
[root@localhost docker]# ls
buildkit  containers  image  network  overlay2  plugins  runtimes  swarm  tmp  trust  volumes
[root@localhost docker]# cd volumes/
[root@localhost volumes]# ls
826c3f1b727ca4077ece894dbc213f2f21ce862dda325c9d63bc55ecc6a96b31  juming-nginx
backingFsBlockDev                                                 metadata.db

我 们通过具名挂载可以方便找到我们的一个卷，大多数情况在使用的具名挂载

1
2
3
4
# 如何确定是具名挂载还是匿名挂载，还是指定路径挂载
-v 容器内路径         # 匿名挂载
-v 卷名：容器内路径    # 具名挂载
-v /宿主机路径：：容器内路径    # 指定路径挂载

拓展

1
2
3
4
5
6
7
8
9
# 通过 -v 容器内路径： ro  rw 改变读写权限
ro    read only      # 只读
rw    read write	 # 可读可写

# 一旦设置了容器权限，容器对我们挂载出来的内容就有限定了
[root@localhost volumes]# docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:ro nginx
[root@localhost volumes]# docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:rw nginx

# ro 只要看到ro就说明这个路径只能通过宿主机来操作，容器内是无法操作的

初始dockerfile

Dockerfile就是用来构建docker镜像的构建文件！命令脚本

通过这个脚本生成镜像，镜像是一层一层的，脚本是一个一个命令，每个命令都是一层

方式二：

1
2
3
4
5
6
7
8
9
10
11
# 创建一个dockerfile文件，名字可以随意，建议dockerfile
# 文件内容 指令大写
FROM centos

VOLUME ["volume01", "volume02"]

CMD echo "----end----"

CMD /bin/bash

# 这里每个命令就是镜像一层
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
[root@localhost docker-test-volune]# docker build -f dockerfile1 -t un1queyan/centos:1.0 .
Sending build context to Docker daemon  2.048kB
Step 1/4 : FROM centos
 ---> 5d0da3dc9764
Step 2/4 : VOLUME ["volume01", "volume02"]
 ---> [Warning] IPv4 forwarding is disabled. Networking will not work.
 ---> Running in 23963d784ced
Removing intermediate container 23963d784ced
 ---> 3902e3981d39
Step 3/4 : CMD echo "----end----"
 ---> [Warning] IPv4 forwarding is disabled. Networking will not work.
 ---> Running in 7c0e6d27bae7
Removing intermediate container 7c0e6d27bae7
 ---> 919d365eaf31
Step 4/4 : CMD /bin/bash
 ---> [Warning] IPv4 forwarding is disabled. Networking will not work.
 ---> Running in 30589ba25e29
Removing intermediate container 30589ba25e29
 ---> 8aea4785d656
Successfully built 8aea4785d656
Successfully tagged un1queyan/centos:1.0
[root@localhost docker-test-volune]# docker images
REPOSITORY            TAG       IMAGE ID       CREATED          SIZE
un1queyan/centos      1.0       8aea4785d656   36 seconds ago   231MB
1
# 启动自己写的容器

image-20211012104940644

这个卷和外部一定有一个卷重复 匿名挂载

查看一下卷挂载的数据

image-20211012105403046

测试一下刚才的文件

我们通常会构建自己的镜像

假设构建镜像没有挂载卷， 要手动镜像挂载 -v 卷名： 容器内路径

1
2
3
[root@localhost home]# cd /var/lib/docker/volumes/cb7a9a6c7f4889b1780ac15274daecb3f74ba7de215d7b2c503ec7a8ae3f60c7/_data
[root@localhost _data]# ls
container.txt

数据卷容器

多个mysql同步数据

image-20211012110236565

image-20211012111009838

多个mysql实现数据共享

1
2
3
[root@localhost un1queyan]# docker run -d -p 3310:3306 -v /home/mysql/conf.d:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7

[root@localhost un1queyan]# docker run -d -p 3310:3306  -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-from mysql01 mysql:5.7

结论：容器之间配置信息的传递，数据卷容器的声明周期一直持续到没有容器使用为止

但是一旦持久化到了本地，本地的数据是不会删除的

DockerFile

dockerfile是用来构建docker镜像的文件，命令参数脚本

构建步骤：

1、编写一个dockerfile文件

2、docker build 构建成为一个镜像

3、docker run运行镜像

4、docker push 发布镜像（DockerHub， 阿里云镜像仓库！）

查看一下官方是怎么做的

image-20211012114553552

很多官方镜像都是基本包，很多功能都没有，我们通常会搭建自己的镜像

DockerFile构建过程

基础知识：

1、每个保留关键字（指令）都必须是大写字母

2、执行顺序从上到下执行

3、# 表示注释

4、每个指令都会创建提交一个新的镜像层，并提交！

image-20211012115136061

dockerfile是面向开发的，我们以后要发布项目，做镜像，就需要编写dockerfile文件。

步骤：开发，部署，上线，运维

Docker镜像逐渐成为了企业交付的标准，必须掌握。

DockerFile：构建文件，定义了一切的步骤，源代码

DockerImages：通过DockerFile构建生成的镜像，最终发布和运行的产品

Docker容器：容器就是镜像运行起来提供服务器

DockerFile的指令

1
2
3
4
5
6
7
8
9
10
11
FROM			# 基础镜像，一切从这里开始构建
MAINTAINER  	# 镜像是谁写的，姓名+邮箱
RUN				# 镜像构建的时候需要运行的命令
ADD				# 步骤：tomcat镜像，这个tomcat压缩包  添加内容
WORKDIR    		# 镜像的工作目录
VOLUME			# 挂载的目录
EXPOSE			# 暴露端口配置 
CMD				# 指定容器启动的时候要运行的命令，只有最后一个会生效，可被替换
ENTRYPOINT		# 指定这个容器启动的时候要运行的命令，可以追加命令
ONBUILD			# 当构建一个被继承 DockerFile 这个时候就会运行 ONBUILD 指令
ENV				# 构建的时候设置环境变量

image-20211012115531059

实战测试

Docker Hub 中 99% 镜像都是从这个基础镜像过来的 FROM scratch，然后配置需要的软件和配置来进行构建

创建一个自己的CentOS

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 1 编写dockerfile的文件
[root@localhost dockerfile]# cat mydockerfile-centos 
FROM centos
MAINTAINER un1queyan<651971356@qq.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 通过这个文件构建镜像
# 命令 docker build -f dockerfile 文件路径 -t 镜像名：[TAG]
Successfully built beb5819ac46f
Successfully tagged mycentos:0.1

# 3 测试运行

之前：

image-20211012151358762

我们增加之后的命令

image-20211012151502452

CMD 和 ENTRYPOINT 区别

1
2
CMD 			# 指定这个容器启动的时候需要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT		# 指定这个容器启动的时候需要运行的命令，可以追加命令

测试CMD

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
[root@localhost dockerfile]# vim dockerfile-cmd-test
FROM centos
CMD ["ls", "-a"]

# 构建镜像
[root@localhost dockerfile]# docker build -f dockerfile-cmd-test -t cmdtest .

# run运行
[root@localhost dockerfile]# docker run da56fe18a7cf
.
..
.dockerenv
bin
dev
etc
home

# 想追加一个命令 -l
[root@localhost dockerfile]# docker run da56fe18a7cf -l
docker: Error response from daemon: OCI runtime create failed: container_linux.go:380: starting container process caused: exec: "-l": executable file not found in $PATH: unknown.
ERRO[0001] error waiting for container: context canceled 

# CMD 的情况下 -l 替换了CMD["ls", "-a"]命令， -l不是命令 所以报错

测试ENTRYPOINT

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
[root@localhost dockerfile]# vim dockerfile-cmd-entry
FROM centos
ENTRYPOINT ["ls", "-a"]

[root@localhost dockerfile]# docker build -f dockerfile-cmd-entry -t entery-test .
Sending build context to Docker daemon  4.096kB
Step 1/2 : FROM centos
 ---> 5d0da3dc9764
Step 2/2 : ENTRYPOINT ["ls", "-a"]
 ---> Running in 7208071529d6
Removing intermediate container 7208071529d6
 ---> 209e1f290f4e
Successfully built 209e1f290f4e
Successfully tagged entery-test:latest
[root@localhost dockerfile]# docker run 209e1f290f4e

.
..
.dockerenv
bin
[root@localhost dockerfile]# 
[root@localhost dockerfile]# docker run 209e1f290f4e -l
total 0
drwxr-xr-x.   1 root root   6 Oct 12 12:20 .
drwxr-xr-x.   1 root root   6 Oct 12 12:20 ..

制作Tomcat镜像

1.准备镜像文件tomcat、jdk压缩包

1
2
3
4
5
6
[root@localhost tomcat]# vi readme.txt
[root@localhost tomcat]# ll
total 200700
-rw-r--r-- 1 root root  10371538 Jan  1 16:11 apache-tomcat-8.5.55.tar.gz
-rw-r--r-- 1 root root 195132576 Jan  1 16:13 jdk-8u251-linux-x64.tar.gz
-rw-r--r-- 1 root root        20 Jan  1 16:14 readme.txt

2.编写dockerfile文件，文件名使用官方命名：Dockerfile ，build的时候会默认寻找当前目录下的文件，不需要使用-f参数指定

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
[root@localhost tomcat]# vim Dockerfile
[root@localhost tomcat]# cat Dockerfile
FROM centos
MAINTAINER ethan<1258398543@qq.com>

COPY readme.txt /usr/local/readme.txt

ADD jdk-8u251-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-8.5.55.tar.gz /usr/local/

RUN yum -y install vim

ENV MYPATH /usr/local
WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_251
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-8.5.55
ENV CATALINA_BASH /usr/local/apache-tomcat-8.5.55
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE 8080

CMD /usr/local/apache-tomcat-8.5.55/bin/startup.sh && tail -F /usr/local/apache-tomcat-8.5.55/bin/logs/catalina.out

3.使用该Dockerfile构建镜像

1
[root@localhost tomcat]# docker build -t diytomcat:1.0 .

4.启动生成的镜像，构建Tomcat容器.

这里设置了数据卷，宿主机的/home/dockerfile/tomcat/test对应该容器的/usr/local/apache-tomcat-8.5.55/webapps/test。这样关于test项目的修复只需要在宿主机上修改就可以了，不需要进入到容器中修改。

1
[root@localhost tomcat]# docker run -d -p 8088:8080 --name diytomcat -v /home/dockerfile/tomcat/test:/usr/local/apache-tomcat-8.5.55/webapps/test diytomcat:1.0
这是个标题

这是一个一个简单的HTML

Hello World！

6.访问测试，浏览器访问查看是否能正常访问

如果页面显示乱码，就需要修改tomcat的server.xml文件

1
2
3
4
  <Connector port="8080" protocol="HTTP/1.1" 
               connectionTimeout="20000" 
               redirectPort="8443" URIEncoding="UTF-8" />
这里是添加了一个属性：URIEncoding，将该属性值设置为UTF-8，即可让Tomcat（默认ISO-8859-1编码）以UTF-8的编码处理get请求。

发布镜像到DockerHub

1.登录https://hub.docker.com/ DockerHub官网进行注册

2.进行登录，docker login -u 用户名

登录命令

1
2
3
4
5
6
7
8
9
10
11
[root@localhost dockerfile]# docker login --help

Usage:  docker login [OPTIONS] [SERVER]

Log in to a Docker registry.
If no server is specified, the default is defined by the daemon.

Options:
  -p, --password string   Password
      --password-stdin    Take the password from stdin
  -u, --username string   Username

3.使用docker push命令推送镜像到DockerHub上的仓库

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
[root@localhost dockerfile]# docker tag 0975df661526 ethanhuang824/diytomcat:1.0
[root@localhost dockerfile]# docker images
REPOSITORY                TAG       IMAGE ID       CREATED             SIZE
diytomcat                 1.0       0975df661526   About an hour ago   688MB
ethanhuang824/diytomcat   1.0       0975df661526   About an hour ago   688MB
cmdtest                   2.0       ac7b7e83ff88   6 hours ago         209MB
cmdtest                   1.0       b6ec5224d2ac   6 hours ago         209MB
ethan/centos              1.0       1df90e6fd790   2 days ago          209MB
mytomcat                  1.0       f189aac861de   3 days ago          653MB
mysql                     5.7       f07dfa83b528   10 days ago         448MB
tomcat                    latest    feba8d001e3f   2 weeks ago         649MB
nginx                     latest    ae2feff98a0c   2 weeks ago         133MB
centos                    latest    300e315adb2f   3 weeks ago         209MB
elasticsearch             7.6.2     f29a1ee41030   9 months ago        791MB
[root@localhost dockerfile]# docker push ethanhuang824/diytomcat:1.0

因为push的时候，镜像名前面需要加上用户名（ethanhuang824是我的用户名。如果用户名不是当前登录用户则会拒绝push请求），所以需要使用命令docker tag 镜像名 新的镜像名复制出一份镜像重新打个Tag。

发布镜像到阿里云容器服务

1.登录阿里云，找到容器镜像服务

2.创建命名空间

4.与上面DockerHub的操作类似，按官方提供的操作指南操作即可。

总结

image-20211012215215730

.

利用dockerfile定制镜像

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
FROM scratch #制作base image 基础镜像，尽量使用官方的image作为base image
FROM centos #使用base image
FROM ubuntu:14.04 #带有tag的base image
LABEL version=“1.0” #容器元信息，帮助信息，Metadata，类似于代码注释
LABEL maintainer=“yc_uuu@163.com"
#对于复杂的RUN命令，避免无用的分层，多条命令用反斜线换行，合成一条命令！
RUN yum update && yum install -y vim \
    Python-dev #反斜线换行
RUN /bin/bash -c "source $HOME/.bashrc;echo $HOME”
WORKDIR /root #相当于linux的cd命令，改变目录，尽量使用绝对路径！！！不要用RUN cd
WORKDIR /test #如果没有就自动创建
WORKDIR demo #再进入demo文件夹
RUN pwd     #打印结果应该是/test/demo
ADD and COPY 
ADD hello /  #把本地文件添加到镜像中，吧本地的hello可执行文件拷贝到镜像的/目录
ADD test.tar.gz /  #添加到根目录并解压
WORKDIR /root
ADD hello test/  #进入/root/ 添加hello可执行命令到test目录下，也就是/root/test/hello 一个绝对路径
COPY hello test/  #等同于上述ADD效果
ADD与COPY
   - 优先使用COPY命令
    -ADD除了COPY功能还有解压功能
添加远程文件/目录使用curl或wget
ENV #环境变量，尽可能使用ENV增加可维护性
ENV MYSQL_VERSION 5.6 #设置一个mysql常量
RUN yum install -y mysql-server=“${MYSQL_VERSION}” 
------这里需要稍微理解一下了-------中级知识---先不讲
VOLUME and EXPOSE 
存储和网络
RUN and CMD and ENTRYPOINT
RUN：执行命令并创建新的Image Layer
CMD：设置容器启动后默认执行的命令和参数
ENTRYPOINT：设置容器启动时运行的命令
Shell格式和Exec格式
RUN yum install -y vim
CMD echo ”hello docker”
ENTRYPOINT echo “hello docker”
Exec格式
RUN [“apt-get”,”install”,”-y”,”vim”]
CMD [“/bin/echo”,”hello docker”]
ENTRYPOINT [“/bin/echo”,”hello docker”]
通过shell格式去运行命令，会读取$name指令，而exec格式是仅仅的执行一个命令，而不是shell指令
cat Dockerfile
    FROM centos
    ENV name Docker
    ENTRYPOINT [“/bin/echo”,”hello $name”]#这个仅仅是执行echo命令，读取不了shell变量
    ENTRYPOINT  [“/bin/bash”,”-c”,”echo hello $name"]
CMD
容器启动时默认执行的命令
如果docker run指定了其他命令(docker run -it [image] /bin/bash )，CMD命令被忽略
如果定义多个CMD，只有最后一个执行
ENTRYPOINT
让容器以应用程序或服务形式运行
不会被忽略，一定会执行
最佳实践：写一个shell脚本作为entrypoint
COPY docker-entrypoint.sh /usr/local/bin
ENTRYPOINT [“docker-entrypoint.sh]
EXPOSE 27017
CMD [“mongod”]
[root@master home]# more Dockerfile
FROm centos
ENV name Docker
#CMD ["/bin/bash","-c","echo hello $name"]
ENTRYPOINT ["/bin/bash","-c","echo hello $name”]

发布docker image到仓库

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
第一种，docker hub公有镜像发布

1.docker提供了一个类似于github的仓库dockerhub,
网址https://hub.docker.com/需要注册使用
2.注册docker id后，在linux中登录dockerhub
docker login
注意要保证image的tag是账户名，如果镜像名字不对，需要改一下tag
docker tag chaoyu/centos-vim yuchao163/centos-vim
语法是：  docker tag   仓库名   yuchao163/仓库名
3.推送docker image到dockerhub
docker push yuchao163/centps-cmd-exec:latest
4.在dockerhub中检查镜像
https://hub.docker.com/
5.删除本地镜像，测试下载pull 镜像文件
docker pull yuchao163/centos-entrypoint-exec
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
私有仓库
但是这种镜像仓库是公开的，其他人也是可以下载，并不安全，因此还可以使用docker registry官方提供的私有仓库

1.官方提供的私有仓库docker registry用法
https://yeasy.gitbooks.io/docker_practice/repository/registry.html
2.一条命令下载registry镜像并且启动私有仓库容器
私有仓库会被创建在容器的/var/lib/registry下，因此通过-v参数将镜像文件存储到本地的/opt/data/registry下
端口映射容器中的5000端口到宿主机的5000端口
docker run -d \
    -p 5000:5000 \
    -v /opt/data/registry:/var/lib/registry \
    registry
3.检查启动的registry容器
docker ps
4.测试连接容器
telnet 192.168.119.10 5000
5.修改镜像tag,以docker registry的地址端口开头
docker tag hello-world:latest 192.168.119.10:5000/hello-world:latest
6.查看docker镜像，找到registry的镜像
docker images
7.Docker 默认不允许非 HTTPS 方式推送镜像。我们可以通过 Docker 的配置选项来取消这个限制，这里必须写正确json数据
[root@master /]# cat /etc/docker/daemon.json
{"registry-mirrors": ["http://95822026.m.daocloud.io"],
"insecure-registries":["192.168.119.10:5000"]
}
写入到docker服务中，写入到[Service]配置块中，加载此配置文件
[root@master home]# grep 'EnvironmentFile=-/etc/docker/daemon.json' /lib/systemd/system/docker.service
EnvironmentFile=/etc/docker/daemon.json
8.修改了docker配置文件，重新加载docker
systemctl daemon-reload
9.重启docker
systemctl restart docker
10.重启了docker，刚才的registry容器进程挂掉了，因此重新启动它
docker ps -a
docker start 容器id
11.推送本地镜像
docker push 192.168.119.10:5000/hello-world
12.由于docker registry没有web节目，但是提供了API数据
官网教程：https://docs.docker.com/registry/spec/api/#listing-repositories
curl http://192.168.119.10:5000/v2/_catalog
或者浏览器访问http://192.168.119.10:5000/v2/_catalog

13.删除本地镜像，从私有仓库中下载
docker pull 192.168.119.10:5000/hello-world

打包flask程序与dockerfile

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
确保app.py和dockerfile在同一个目录！
1.准备好app.py的flask程序
[root@master home]# cat app.py
from flask import Flask
app=Flask(__name__)
@app.route('/')
def hello():
    return "hello docker"
if __name__=="__main__":
    app.run(host='0.0.0.0',port=8080)
[root@master home]# ls
app.py  Dockerfile
2.编写dockerfile
[root@master home]# cat Dockerfile
FROM python:2.7
LABEL maintainer="Chao Yu<yc_uuu@163.com>"
RUN pip install flask
COPY app.py /app/
WORKDIR /app
EXPOSE 8080
CMD ["python","app.py"]
3.构建镜像image
docker build -t yuchao163/flask-hello-docker .
4.查看创建好的images
docker image ls
5.启动此flask-hello-docker容器，映射一个端口供外部访问
docker run -d -p 8080:8080 yuchao163/flask-hello-docker
6.检查运行的容器
docker container ls
赏

老板大气

支付宝
微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家