随心玩玩（四）docker从入门到入土

垂死病中惊坐起，原来今天星期一。

---

---

前置学习 linux实践
https://blog.csdn.net/qq_19841133/article/details/108574319

Docker概述

docker为什么会出现？

开发要配置环境，项目开发上线环境部署也要配置环境，十分的麻烦。

在项目发布时，使用docker就可以将项目带上环境一块打包。

Docker的思想来自于集装箱，项目打包放入集装箱中，每个箱子间相互隔离。

docker通过隔离机制避免端口号之间冲突。

docker是基于go语言开发的开源项目。

---

虚拟机和docker都是虚拟化技术

虚拟机模拟一个完整的操作系统，和虚拟机不同，docker镜像只存放核心的环境，运行于操作系统之上。

---

官网：https://www.docker.com/

文档位置：https://docs.docker.com/

docker架构图

分为三部分，客户端，docker服务器，远程仓库。

客户端用command操作docker，docker daemon是守护进程，镜像去运行容器。

镜像 image：镜像就好比一个模板，可以通过这个模板创建容器，将服务启动起来。通过这个镜像可以启动多个容器。

容器 container：服务运行在容器中，容器之间相互隔离，独立运行一组应用。

仓库 repository：存放镜像，和github概念差不多，docker hub

安装docker

环境准备

Centos7

系统内核3.10

[root @ VM-8-3-centos ~] # uname -r
3.10.0-1160.11.1.el7.x86_64
[root @ VM-8-3-centos ~] # sudo cat /etc/os-release
NAME="CentOS Linux"
VERSION="7 (Core)"
ID="centos"
ID_LIKE="rhel fedora"
VERSION_ID="7"
PRETTY_NAME="CentOS Linux 7 (Core)"
ANSI_COLOR="0;31"
CPE_NAME="cpe:/o:centos:centos:7"
HOME_URL="https://www.centos.org/"
BUG_REPORT_URL="https://bugs.centos.org/"

CENTOS_MANTISBT_PROJECT="CentOS-7"
CENTOS_MANTISBT_PROJECT_VERSION="7"
REDHAT_SUPPORT_PRODUCT="centos"
REDHAT_SUPPORT_PRODUCT_VERSION="7"

开始学习安装，一起始于文档https://docs.docker.com/

选系统版本

先卸载旧的docker

sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

跟着文档做就好，docker文档十分详细

# provides the yum-config-manager utility
sudo yum install -y yum-utils
# add mirror
sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
# 更新索引
sudo yum makecache fast
# install docker
sudo yum install docker-ce docker-ce-cli containerd.io
# 启动docker
sudo systemctl start docker
# 设置开机自启动
systemctl enable docker.service
# hello world
sudo docker run hello-world

正确安装显示

Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
0e03bdcc26d7: Pull complete
Digest: sha256:31b9c7d48790f0d8c50ab433d9c3b7e17666d6993084c002c2ff1ca09b96391d
Status: Downloaded newer image for hello-world:latest

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/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

helloworld例子工作流程：docker在本机寻找镜像，有的话使用镜像运行，没有的话下载镜像，DockerHub是否可以找到这个镜像，找到了下载，找不到报错。

查看镜像

[root @ VM-8-3-centos ~] # docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
hello-world   latest    bf756fb1ae65   12 months ago   13.3kB

卸载docker操作：

Uninstall Docker Engine
Uninstall the Docker Engine, CLI, and Containerd packages:
卸载依赖
sudo yum remove docker-ce docker-ce-cli containerd.io
Images, containers, volumes, or customized configuration files on your host are not automatically removed. To delete all images, containers, and volumes:
删除运行环境
sudo rm -rf /var/lib/docker
You must delete any edited configuration files manually.

如何配置镜像加速

默认情况下，Docker 下载镜像是从官网下载，下载速度 特别特别的慢
使用国内加速器可以提升获取 Docker 官方镜像的速度

直接复制即可到 Linux 下回车即可

配置多个地址，避免某个站点不行时自动切换到后面的站点

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["http://hub-mirror.c.163.com",
    "https://docker.mirrors.ustc.edu.cn",
    "https://reg-mirror.qiniu.com"
  ]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

工作原理

docker是一个Client/Server结构，docker的守护进程运行在主机上，通过Socket从客户端访问服务器，Docker Server接收到Docker Client指令并执行。这里的守护进程就充当着服务器的角色，守护进程启动容器。

docker比虚拟机有更少的抽象层。VM需要OS，而Docker直接利用内核由Docker Engine统一管理。

镜像常用命令

显示信息
docker version
docker info

帮助命令
docker --help

文档地址：https://docs.docker.com/reference/

查看主机上的镜像
docker images

[root @ VM-8-3-centos ~] # docker images --help

Usage:  docker images [OPTIONS] [REPOSITORY[:TAG]]

List images

Options:
  -a, --all             Show all images (default hides intermediate images) 显示所有信息 
      --digests         Show digests 
  -f, --filter filter   Filter output based on conditions provided
      --format string   Pretty-print images using a Go template
      --no-trunc        Don't truncate output
  -q, --quiet           Only show image IDs  只显示id

dockerhub地址：https://hub.docker.com/

比如我想装mysql：https://hub.docker.com/_/mysql

可以用搜索命令

docker search mysql

拉取命令

docker pull mysql 和docker pull docker.io/library/mysql:latest等价

[root @ VM-8-3-centos ~] # docker pull mysql
Using default tag: latest
latest: Pulling from library/mysql   # 分层下载
a076a628af6f: Pull complete
f6c208f3f991: Pull complete
88a9455a9165: Pull complete
406c9b8427c6: Pull complete
7c88599c0b25: Pull complete
25b5c6debdaf: Pull complete
43a5816f1617: Pull complete
1a8c919e89bf: Pull complete
9f3cf4bd1a07: Pull complete
80539cea118d: Pull complete
201b3cad54ce: Pull complete
944ba37e1c06: Pull complete
Digest: sha256:feada149cb8ff54eade1336da7c1d080c4a1c7ed82b5e320efb5beebed85ae8c
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest # 真实地址

docker pull name[:版本]

在docker hub查看镜像支持的版本

[root @ VM-8-3-centos ~] # docker pull mysql:5.7
5.7: Pulling from library/mysql
a076a628af6f: Already exists  # 联合文件系统，重复的就不下载了
f6c208f3f991: Already exists
88a9455a9165: Already exists
406c9b8427c6: Already exists
7c88599c0b25: Already exists
25b5c6debdaf: Already exists
43a5816f1617: Already exists
1831ac1245f4: Pull complete
37677b8c1f79: Pull complete
27e4ac3b0f6e: Pull complete
7227baa8c445: Pull complete
Digest: sha256:b3d1eff023f698cd433695c9506171f0d08a8f92a0c8063c1a4d9db9a55808df
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7

删除镜像

docker rmi name|id

删除所有镜像
docker rmi -f ${docker images -aq}

容器常用命令

我有了镜像才能创建容器，下载一个centos镜像

[root @ VM-8-3-centos ~] # docker pull centos
Using default tag: latest
latest: Pulling from library/centos
7a0437f04f83: Pull complete
Digest: sha256:5528e8b1b1719d34604c87e11dcd1c0a20bedf46e83b5632cdeac91b8c04efc1
Status: Downloaded newer image for centos:latest
docker.io/library/centos:latest

通过docker run命令

启动容器
docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

常用Option

--name centos1  容器名字
--d  后台方式运行
-it  使用交互方式运行
-p  指定端口
  -p 宿主机端口:容器端口（常用）
  -p 容器端口
  -p ip:主机端口:容器端口
-P  随机指定端口

启动并进入容器
docker run -it centos /bin/bash

[root @ VM-8-3-centos ~] # docker run  -it centos /bin/bash
[root@3a8a6bcb1068 /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
[root@3a8a6bcb1068 /]# uname -r
3.10.0-1160.11.1.el7.x86_64
[root@3a8a6bcb1068 /]# exit
exit

查看运行中的容器

docker ps [-a] [-n=?] [q]

[root @ VM-8-3-centos ~] # docker ps -a
CONTAINER ID   IMAGE         COMMAND       CREATED       STATUS                   PORTS     NAMES
3a8a6bcb1068   centos        "/bin/bash"   3 hours ago   Exited (0) 3 hours ago             pedantic_archimedes
68cc5263bb91   hello-world   "/hello"      4 hours ago   Exited (0) 4 hours ago             silly_kalam

退出容器

exit 退出并停止
ctrl+p+q不停止退出

[root @ VM-8-3-centos ~] # docker run -it centos /bin/bash
[root@b74fbc687731 /]# [root @ VM-8-3-centos ~] #
[root @ VM-8-3-centos ~] #
[root @ VM-8-3-centos ~] #
[root @ VM-8-3-centos ~] # docker ps
CONTAINER ID   IMAGE     COMMAND       CREATED          STATUS          PORTS     NAMES
b74fbc687731   centos    "/bin/bash"   18 seconds ago   Up 17 seconds             sad_galileo

删除容器

docker rm id

删除所有容器，运行中的不能删除，加上-f
docker rm -f $(docker ps -aq)

[root @ VM-8-3-centos ~] # docker ps -a
CONTAINER ID   IMAGE         COMMAND       CREATED              STATUS                   PORTS     NAMES
b74fbc687731   centos        "/bin/bash"   About a minute ago   Up About a minute                  sad_galileo
3a8a6bcb1068   centos        "/bin/bash"   3 hours ago          Exited (0) 3 hours ago             pedantic_archimedes
68cc5263bb91   hello-world   "/hello"      4 hours ago          Exited (0) 4 hours ago             silly_kalam
[root @ VM-8-3-centos ~] # docker rm -f $(docker ps -aq)
b74fbc687731
3a8a6bcb1068
68cc5263bb91

删除所有容器，管道用法
docker ps -a -q | xargs docker rm

启动容器
docker start id

重启容器
docker restart id

停止容器
docker stop|kill id

常用的其他命令

后台启动容器
docker run -d id|name

docker run -d centos 发现启动后centos停止了

[root @ VM-8-3-centos ~] # docker run -d centos
5fba04196af1ad5306a2613ffe4f47d1e9de6c204ee4f4fac36718057da71f85
[root @ VM-8-3-centos ~] #
[root @ VM-8-3-centos ~] #
[root @ VM-8-3-centos ~] # docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
[root @ VM-8-3-centos ~] #

docker容器使用后台运行，必须要有一个前台进程 如-it。

docker发现后台没有对外提供的服务，就会自动停止。常见的nginx容器启动后立刻停止。

查看日志
docker logs [option] container

Usage:  docker logs [OPTIONS] CONTAINER

Fetch the logs of a container

Options:
      --details        Show extra details provided to logs
  -f, --follow         Follow log output
      --since string   Show logs since timestamp (e.g. 2013-01-02T13:23:37Z) or relative (e.g. 42m for 42
                       minutes)
  -n, --tail string    Number of lines to show from the end of the logs (default "all")
  -t, --timestamps     Show timestamps
      --until string   Show logs before a timestamp (e.g. 2013-01-02T13:23:37Z) or relative (e.g. 42m for
                       42 minutes)

docker -tf --tail 10 id

-tf 显示日志和时间戳
–tail num 显示最新的num行日志

[root @ VM-8-3-centos ~] # docker run -d centos /bin/sh -c "while true;do echo 123;sleep 1;done"
441a96813ecf2a22bcdf557295e05a7b546ac86228dcae496de35179bcdc4d73
[root @ VM-8-3-centos ~] #
[root @ VM-8-3-centos ~] # docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS     NAMES
441a96813ecf   centos    "/bin/sh -c 'while t…"   2 seconds ago   Up 2 seconds             dazzling_cerf
[root @ VM-8-3-centos ~] #
[root @ VM-8-3-centos ~] # docker logs -f -t --tail 10 441a96813ecf
2021-01-26T05:06:35.863389675Z 123
2021-01-26T05:06:36.865628642Z 123
2021-01-26T05:06:37.867550699Z 123
2021-01-26T05:06:38.869527853Z 123
2021-01-26T05:06:39.871557044Z 123

查看容器中的进程

docker top id

[root @ VM-8-3-centos ~] # docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS     NAMES
441a96813ecf   centos    "/bin/sh -c 'while t…"   2 minutes ago   Up 2 minutes             dazzling_cerf
[root @ VM-8-3-centos ~] #
[root @ VM-8-3-centos ~] #
[root @ VM-8-3-centos ~] # docker top 441a96813ecf
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                543                 520                 0                   13:05               ?                   00:00:00            /bin/sh -c while true;do echo 123;sleep 1;done
root                1648                543                 0                   13:10               ?                   00:00:00            /usr/bin/coreutils --coreutils-prog-shebang=sleep /usr/bin/sleep 1
[root @ VM-8-3-centos ~] #

查看镜像的元数据

docker inspect [option] name|id

[root @ VM-8-3-centos ~] # docker inspect 441a96813ecf
[
    {
        "Id": "441a96813ecf2a22bcdf557295e05a7b546ac86228dcae496de35179bcdc4d73",
        "Created": "2021-01-26T05:05:36.377119331Z",
        "Path": "/bin/sh",
        // 传递的参数
        "Args": [
            "-c",
            "while true;do echo 123;sleep 1;done"
        ],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 543,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2021-01-26T05:05:36.737112206Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:300e315adb2f96afe5f0b2780b87f28ae95231fe3bdd1e16b9ba606307728f55",
        "ResolvConfPath": "/var/lib/docker/containers/441a96813ecf2a22bcdf557295e05a7b546ac86228dcae496de35179bcdc4d73/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/441a96813ecf2a22bcdf557295e05a7b546ac86228dcae496de35179bcdc4d73/hostname",
        "HostsPath": "/var/lib/docker/containers/441a96813ecf2a22bcdf557295e05a7b546ac86228dcae496de35179bcdc4d73/hosts",
        "LogPath": "/var/lib/docker/containers/441a96813ecf2a22bcdf557295e05a7b546ac86228dcae496de35179bcdc4d73/441a96813ecf2a22bcdf557295e05a7b546ac86228dcae496de35179bcdc4d73-json.log",
      		...
      		
            "Networks": {
                "bridge": {
                    "IPAMConfig": null,
                    "Links": null,
                    "Aliases": null,
                    "NetworkID": "1abd08b32583ccc8fdd1c0e8b091170919727da2abbce89f2120a75be9030e7d",
                    "EndpointID": "3ef6fa2e0b4777a09cfe58a675a4e182d16980cc532ff66be6abe8ffa1770a0e",
                    "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
                }
            }
        }
    }
]
[root @ VM-8-3-centos ~] #

进入当前正在运行的容器

方式1：
docker exec -it id /bin/bash

新建一个bash进入

[root @ VM-8-3-centos ~] # docker exec -it 441a96813ecf /bin/bash
[root@441a96813ecf /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
[root@441a96813ecf /]#
[root@441a96813ecf /]# ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 05:05 ?        00:00:00 /bin/sh -c while true;do echo 123;sleep 1;done
root       827     0  0 05:19 pts/0    00:00:00 /bin/bash
root       869     1  0 05:19 ?        00:00:00 /usr/bin/coreutils --coreutils-prog-shebang=sleep /usr/bin/sleep
root       870   827  0 05:19 pts/0    00:00:00 ps -ef
[root@441a96813ecf /]#

方式2：
docker attach id
进入正在运行的命令窗口

[root @ VM-8-3-centos ~] #  docker attach 441a96813ecf
123
123

从容器内拷贝文件到主机上
docker cp 容器id:容器内路径 目的主机路径

docker cp fedc8c32b382:/tmp/1.txt ~/

---

---

部署Nginx

docker hub搜索nginx
docker pull nginx

docker images

-p 宿主机端口:内部端口
docker run -d --name nginx01 -p 3344:80 nginx

发起请求测试

[root @ VM-8-3-centos ~] # curl localhost:3344
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
    body {
        width: 35em;
        margin: 0 auto;
        font-family: Tahoma, Verdana, Arial, sans-serif;
    }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

网页测试

端口暴露原理分析

docker帮我们做了一层mapping，主机端口映射到容器内部端口

nginx因为没服务可能会自动关闭

[root @ VM-8-3-centos ~] # docker ps -a
CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS                          PORTS     NAMES
8d8e7ee85c76   nginx     "/docker-entrypoint.…"   10 minutes ago   Exited (0) About a minute ago             nginx01
fedc8c32b382   centos    "/bin/bash"              25 minutes ago   Exited (0) 22 minutes ago                 wizardly_keldysh
[root @ VM-8-3-centos ~] # docker start 8d8e7ee85c76
8d8e7ee85c76
[root @ VM-8-3-centos ~] #
[root @ VM-8-3-centos ~] # docker ps -a
CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS                      PORTS                  NAMES
8d8e7ee85c76   nginx     "/docker-entrypoint.…"   10 minutes ago   Up 2 seconds                0.0.0.0:3344->80/tcp   nginx01
fedc8c32b382   centos    "/bin/bash"              25 minutes ago   Exited (0) 23 minutes ago                          wizardly_keldysh
[root @ VM-8-3-centos ~] # docker exec -it nginx01 /bin/bash
root@8d8e7ee85c76:/#

进入容器
docker exec -it nginx01 /bin/bash

[root @ VM-8-3-centos ~] # docker exec -it nginx01 /bin/bash
root@8d8e7ee85c76:/# whereis nginx
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx
root@8d8e7ee85c76:/# cd /etc/nginx
# 查看配置文件
root@8d8e7ee85c76:/etc/nginx# ls
conf.d          koi-utf  mime.types  nginx.conf   uwsgi_params
fastcgi_params  koi-win  modules     scgi_params  win-utf
root@8d8e7ee85c76:/etc/nginx#

停止容器

docker stop nginx01

部署tomcat

官方文档

官方加了 --rm ，一般是用来测试的，用完即删，前期不推荐这么用
–rm Automatically remove the container when it exits

---

docker pull tomcat:9.0

docker images

docker run -d -p 7010:8080 --name tomcat01 tomcat:9.0

访问测试

进入其查看内容，linux命令少了，webapps内没有网站，只是因为下载的镜像默认最小可用

[root @ VM-8-3-centos ~] # docker exec -it tomcat01 /bin/bash
root@96901ce17c70:/usr/local/tomcat#
root@96901ce17c70:/usr/local/tomcat#
root@96901ce17c70:/usr/local/tomcat# ls -al
total 172
drwxr-xr-x 1 root root  4096 Jan 13 08:25 .
drwxr-xr-x 1 root root  4096 Jan 13 08:19 ..
-rw-r--r-- 1 root root 18982 Dec  3 11:48 BUILDING.txt
-rw-r--r-- 1 root root  5409 Dec  3 11:48 CONTRIBUTING.md
-rw-r--r-- 1 root root 57092 Dec  3 11:48 LICENSE
-rw-r--r-- 1 root root  2333 Dec  3 11:48 NOTICE
-rw-r--r-- 1 root root  3257 Dec  3 11:48 README.md
-rw-r--r-- 1 root root  6898 Dec  3 11:48 RELEASE-NOTES
-rw-r--r-- 1 root root 16507 Dec  3 11:48 RUNNING.txt
drwxr-xr-x 2 root root  4096 Jan 13 08:25 bin
drwxr-xr-x 1 root root  4096 Jan 26 06:21 conf
drwxr-xr-x 2 root root  4096 Jan 13 08:25 lib
drwxrwxrwx 1 root root  4096 Jan 26 06:21 logs
drwxr-xr-x 2 root root  4096 Jan 13 08:25 native-jni-lib
drwxrwxrwx 2 root root  4096 Jan 13 08:25 temp
drwxr-xr-x 2 root root  4096 Jan 13 08:25 webapps
drwxr-xr-x 7 root root  4096 Dec  3 11:45 webapps.dist
drwxrwxrwx 2 root root  4096 Dec  3 11:43 work
root@96901ce17c70:/usr/local/tomcat#

webapps.dist中存放了原来webapps的东西，我们可以把它拷贝过去

root@96901ce17c70:/usr/local/tomcat# cd webapps
root@96901ce17c70:/usr/local/tomcat/webapps# ls
ROOT  docs  examples  host-manager  manager

回浏览器查看主页

部署Es+Kibana

---

因为Elasticsearch 是一个基于 Apache Lucene™ 的开源搜索引擎。无论在开源还是专有领域，Lucene 可以被认为是迄今为止最先进、性能最好的、功能最全的搜索引擎库。

kibana工具是提供了一个可视化的界面。
我们的es需要以基于 HTTP 协议，以 JSON 为数据交互格式的 RESTful API来进行交互！
Kibana 可以看出是一个操作 ElasticSeach 的客户端.
由于Kibana是用nodejs写的一个web项目。所以进程查询使用ps来进行查询区别es用jps查询！

---

查看官网

$ docker network create somenetwork
Run Elasticsearch:

$ docker run -d --name elasticsearch --net somenetwork -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:tag

下载启动elasticsearch
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2

docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2

启动后就卡住了，es十分的占内存，docker stats查看cpu状态

访问9200端口查看运行状态

停止docker stop，增加内存限制再启动

通过-e进行环境配置修改，限制内存启动

docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2

再次查看一下内存状态，占用率降低

kibana和Es如何通信呢？

通过linux内网转发，而不是通过外网ip，需要了解docker的网络原理

可视化管理面板

使用portainer

Portainer is a lightweight management UI which allows you to easily manage your Docker host or Swarm cluster.

图形化后台管理面板

官方文档
https://documentation.portainer.io/v2.0/deploy/linux/

docker run -d -p 8000:8000 -p 9000:9000 --name=portainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer-ce

访问地址

配置好密码，即可进入主页

查看镜像

查看容器

继续浅入了解docker

docker镜像

镜像是什么？镜像是一种轻量级、可执行的独立软件包，包括代码、运行时库、环境和配置文件。

联合文件系统

UnionFs联合文件系统，Union文件系统是一种分层的轻量级且高性能的文件系统。镜像可以通过分层来进行继承，基于基础镜像，通过叠加文件，可以制作各种具体的应用镜像。

我们在下载镜像时，是一层一层文件下载的，有重复的文件时不会下载，优化存储空间。

docker镜像加载原理

docker的镜像实际上由一层一层的文件系统构成。

bootfs：系统启动需要引导加载，bootfs包含加载器和内核，服务运行起来了bootfs引导就没用了，bootfs会被卸载。bootfs对于所有镜像是公用的。

rootfs：包含/dev、/etc等典型的linux目录，所以说为什么启动一个容器就是启动了一个小的linux

对于一个精简的OS，rootfs可以很小，只需要包含最基本的命令和程序库即可，底层直接用宿主机的内核，镜像只要提供rootfs就可以了。可见对于不同的linux版本，bootfs基本是一致的，rootfs稍有差别。

分层

通过inspect指令查看元数据可以看到分层结构

docker inspect redis

  "RootFS": {
            "Type": "layers",
            "Layers": [
                "sha256:cb42413394c4059335228c137fe884ff3ab8946a014014309676c25e3ac86864",
                "sha256:8e14cb7841faede6e42ab797f915c329c22f3b39026f8338c4c75de26e5d4e82",
                "sha256:1450b8f0019c829e638ab5c1f3c2674d117517669e41dd2d0409a668e0807e96",
                "sha256:f927192cc30cb53065dc266f78ff12dc06651d6eb84088e82be2d98ac47d42a0",
                "sha256:a24a292d018421783c491bc72f6601908cb844b17427bac92f0a22f5fd809665",
                "sha256:3480f9cdd491225670e9899786128ffe47054b0a5d54c48f6b10623d2f340632"
            ]
        },

镜像都基于一个基础镜像，通过叠加文件，可以制作新的镜像。类似于windows打安全补丁。

镜像之间的文件可以复用。镜像之间某层文件是相同的就不用重复下载了。

镜像与容器关联

镜像都是只读的，当容器启动时，一个新的可写层被加载到镜像顶部。
这一层就是就是容器层，容器之下叫镜像层。

docker commit 自己的容器

docker commit 提交容器成为一个新的镜像

类似git的操作

docker commit -m “描述信息” -a “作者” 容器id 目标镜像名[:tag]

首先启动我们的tomcat镜像作为例子
docker run -d -p 7010:8080 --name tomcat01 tomcat:9.0

docker exec -it tomcat01 /bin/bash

cp -r webapps.dist/* webapps

提交我们自己的镜像
docker commit -a="likeghee" -m="add webapps app" tomcat01 mytomcat:1.0
docker commit -m=“描述信息” -a=“作者” 容器id 目标镜像名[:tag]

以后我们可以使用自己镜像了

[root @ VM-8-3-centos ~] # docker images
REPOSITORY               TAG       IMAGE ID       CREATED         SIZE
mytomcat                 1.0       fed9dbf45383   6 seconds ago   654MB

---

================

| docker入门分界线 |

================

---

动态添加端口

经常遇到这个问题，就顺便放到这了：https://zhuanlan.zhihu.com/p/65938559

容器数据卷

应用和环境打包成一个镜像，通过镜像可以启动容器，而数据不应该保存在容器中，容器一删除数据都丢失。

比如安装mysql容器，容器删了里面存的数据一块丢了，等于删库跑路了

什么是容器数据卷？
我们希望容器之间有一个数据共享的技术，Docker容器中产生的数据同步到本地，数据存放在本地数据就不会丢失了，简单的说，就是将容器内的目录挂载到linux文件系统上。

作用：容器数据持久化和同步，容器间数共享。

使用-v命令挂载

docker run -it -v 主机目录:容器目录

docker run -it --name centos01 -v /home/test:/home centos /bin/bash

测试文件同步

查看inspect

	 "Mounts": [
            {
                "Type": "bind",
                "Source": "/home/test",
                "Destination": "/home",
                "Mode": "",
                "RW": true,
                "Propagation": "rprivate"
            }
        ],

以后我们修改文件只要在linux主机上修改即可

部署mysql-同步数据

官方文档操作：

$ docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

-d 后台运行
-p 端口映射
-v 数据卷挂载
:/etc/mysql/conf 配置文件
:/var/lib/mysql 数据文件
-e 环境配置
MYSQL_ROOT_PASSWORD=配置密码

docker run -d -p 3306:3306 -v /home/mysql01/conf:/etc/mysql/conf -v /home/mysql01/data:/var/lib/mysql --name mysql01 -e MYSQL_ROOT_PASSWORD=■■■■■■■ mysql:5.7

顺便把phpmyadmin开了，访问likeghee.ltd:8888即可
docker run -d --name myadmin -e PMA_HOST=likeghee.ltd -e PMA_PORT=3306 -p 8888:80 phpmyadmin/phpmyadmin
👆命令说明：

-e PMA_HOST= 数据库的IP地址
-e PMA_PORT=3306 数据库的端口
-p 8888:80 将容器80端口映射到主机的8888端口
–name myadmin 将容器命名为myadmin

使用sqlyog测试连接

我们新建一个test数据

然后我们在linux上查看数据，就不用进到容器中了

具名和匿名挂载

什么是匿名挂载？

匿名挂载
-v 容器内路径，容器会自动帮我们挂载到主机的一个地方

docker run -d -P --name nginx02 -v /etc/nginx nginx

通过docker volume 查看卷情况

docker volume ls

[root @ VM-8-3-centos data] # docker volume ls
DRIVER    VOLUME NAME
local     1e6e6eb3fb80e88e8dcde3ac0e99a361641866b1a1f7bc2632931ba233c1cb64
local     portainer_data

像1e6e6eb3fb80e88e8dcde3ac0e99a361641866b1a1f7bc2632931ba233c1cb64就是匿名卷挂载

具名挂载
docker run -d -P --name nginx03 -v jumingNginx:/etc/nginx nginx
-v 后面不用/开头表示名字，/开头就是路径

have you seen here? 有个名字叫jumingNginx的卷

[root @ VM-8-3-centos data] # docker volume ls
DRIVER    VOLUME NAME
local     1e6e6eb3fb80e88e8dcde3ac0e99a361641866b1a1f7bc2632931ba233c1cb64
local     jumingNginx
local     portainer_data

查看卷位置

docker volume inspect jumingNginx

[root @ VM-8-3-centos data] # docker volume inspect jumingNginx
[
    {
        "CreatedAt": "2021-01-26T16:34:42+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/jumingNginx/_data",
        "Name": "jumingNginx",
        "Options": null,
        "Scope": "local"
    }
]

Mountpoint就是具体对应的路径

/var/lib/docker/volumes/下如果没有设置路径默认的存放位置存放着所有卷数据

指定路径挂载
-v /path:/path

ro和rw
docker run -d -P --name nginx04 -v jumingNginx4:/etc/nginx:ro nginx

-v /path最后面跟着:ro和:rw是什么意思？

改变读写权限

ro = read only
rw = 可读可写（默认）

一旦设定ro，容器内部的数据就有限定了，只能从外部改变，不能容器内部改变。

Dockerfile初识

dockerfile用来构建docker镜像的构建文件

等于手工打造镜像，通过脚本生成镜像。

编写dockerfile，
FROM centos 表示基于centos

VOLUME [“volume01”, “volume02”]在创建容器的时候就将这两个数据卷匿名挂载出来

FROM centos

VOLUME ["volume01", "volume02"]

CMD echo "---end---"

CMD /bin/bash

docker build -f dockerfile -t likeghee/centos .

dockerfile是编写脚本的名字
likeghee/centos[:tag]是镜像名字

-t, --tag list Name and optionally a tag in the ‘name:tag’ format
-f, --file string Name of the Dockerfile (Default is ‘PATH/Dockerfile’)

build一下dockerfile

[root @ VM-8-3-centos docker-test-volume] # docker build -f dockerfile -t likeghee/centos .
Sending build context to Docker daemon  2.048kB
Step 1/4 : FROM centos
 ---> 300e315adb2f
Step 2/4 : VOLUME ["volume01", "volume02"]
 ---> Running in 067136e98766
Removing intermediate container 067136e98766
 ---> 622a56fbefbf
Step 3/4 : CMD echo "---end---"
 ---> Running in 0ddcb795c723
Removing intermediate container 0ddcb795c723
 ---> b3a7f07e7474
Step 4/4 : CMD /bin/bash
 ---> Running in 46277209c83a
Removing intermediate container 46277209c83a
 ---> f95ed435e1b2
Successfully built f95ed435e1b2
Successfully tagged likeghee/centos:latest

成功生成自己的镜像likeghee/centos:latest
可以看到images id为f95ed435e1b2

[root @ VM-8-3-centos docker-test-volume] # docker images
REPOSITORY               TAG       IMAGE ID       CREATED         SIZE
likeghee/centos          latest    f95ed435e1b2   2 minutes ago   209MB

通过镜像id启动容器，注意这里没有-v
docker run -it --name centos01 f95ed435e1b2 /bin/bash

可以看到有volume01和volume02数据卷帮我们自动挂载出来了

[root@cc4239cf8ec1 /]# docker run -it f95ed435e1b2 /bin/bash
[root@cc4239cf8ec1 /]# ls -l
total 56
lrwxrwxrwx   1 root root    7 Nov  3 15:22 bin -> usr/bin
drwxr-xr-x   5 root root  360 Jan 26 10:02 dev
drwxr-xr-x   1 root root 4096 Jan 26 10:02 etc
drwxr-xr-x   2 root root 4096 Nov  3 15:22 home
lrwxrwxrwx   1 root root    7 Nov  3 15:22 lib -> usr/lib
lrwxrwxrwx   1 root root    9 Nov  3 15:22 lib64 -> usr/lib64
drwx------   2 root root 4096 Dec  4 17:37 lost+found
drwxr-xr-x   2 root root 4096 Nov  3 15:22 media
drwxr-xr-x   2 root root 4096 Nov  3 15:22 mnt
drwxr-xr-x   2 root root 4096 Nov  3 15:22 opt
dr-xr-xr-x 131 root root    0 Jan 26 10:02 proc
dr-xr-x---   2 root root 4096 Dec  4 17:37 root
drwxr-xr-x  11 root root 4096 Dec  4 17:37 run
lrwxrwxrwx   1 root root    8 Nov  3 15:22 sbin -> usr/sbin
drwxr-xr-x   2 root root 4096 Nov  3 15:22 srv
dr-xr-xr-x  13 root root    0 Jan 26 10:02 sys
drwxrwxrwt   7 root root 4096 Dec  4 17:37 tmp
drwxr-xr-x  12 root root 4096 Dec  4 17:37 usr
drwxr-xr-x  20 root root 4096 Dec  4 17:37 var
drwxr-xr-x   2 root root 4096 Jan 26 10:02 volume01
drwxr-xr-x   2 root root 4096 Jan 26 10:02 volume02

volume01和volume02这两个卷一定是和我们linux主机某个地方挂载的

我们去找一下

[root @ VM-8-3-centos docker-test-volume] # find / -name flag.txt
/var/lib/docker/volumes/a47bd64ff2add27a1951a5d574d1d3edeb62b7f5b305beb29dc17f8fe2b8829d/_data/flag.txt

也可以通过docker inspect可以查看mount位置

这种方式未来我们使用方便许多，构造镜像的时候不用通过-v手动挂载路径了，通过dockerfile写在镜像中自动帮我们挂载了。

–volume-from 实现数据同步

数据卷容器

容器a通过–volume-from挂载容器b，实现数据同步，如多个mysql数据同步

这里容器b称为父容器也叫数据卷容器，容器a称为子容器。

docker images

启动容器1
docker run -it --name centos01 likeghee/centos

启动容器2并和容器1数据绑定
docker run -it --name centos02 --volumes-from centos01 likeghee/centos

测试数据是否同步

[root @ VM-8-3-centos docker-test-volume] # docker run -it --name centos02 --volumes-from centos01 likeghee/centos
[root@4e5216b1746b /]#
[root@4e5216b1746b /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var  volume01  volume02
[root@4e5216b1746b /]#
[root@4e5216b1746b /]# cd volume01
[root@4e5216b1746b volume01]#
[root@4e5216b1746b volume01]# touch abc.txt
[root@4e5216b1746b volume01]#
[root@4e5216b1746b volume01]# [root @ VM-8-3-centos docker-test-volume] #
[root @ VM-8-3-centos docker-test-volume] #
[root @ VM-8-3-centos docker-test-volume] # docker ps
CONTAINER ID   IMAGE                    COMMAND                  CREATED          STATUS          PORTS                                            NAMES
4e5216b1746b   likeghee/centos          "/bin/sh -c /bin/bash"   58 seconds ago   Up 57 seconds                                                    centos02
31bbf1d53e8a   likeghee/centos          "/bin/sh -c /bin/bash"   3 minutes ago    Up 3 minutes                                                     centos01
dc645de9df49   portainer/portainer-ce   "/portainer"             8 minutes ago    Up 8 minutes    0.0.0.0:8000->8000/tcp, 0.0.0.0:9000->9000/tcp   portainer
[root @ VM-8-3-centos docker-test-volume] # docker attach centos01
[root@31bbf1d53e8a /]#
[root@31bbf1d53e8a /]# cd volume01
[root@31bbf1d53e8a volume01]# ls
abc.txt
[root@31bbf1d53e8a volume01]#
[root@31bbf1d53e8a volume01]# touch bbb.txt
[root@31bbf1d53e8a volume01]#
[root@31bbf1d53e8a volume01]#
[root@31bbf1d53e8a volume01]# read escape sequence
[root @ VM-8-3-centos docker-test-volume] #
[root @ VM-8-3-centos docker-test-volume] #
[root @ VM-8-3-centos docker-test-volume] # docker attach centos02
[root@4e5216b1746b volume01]#
[root@4e5216b1746b volume01]# ls
abc.txt  bbb.txt
[root@4e5216b1746b volume01]#

如果把数据卷容器删除，数据还存在吗？

[root @ VM-8-3-centos docker-test-volume] # docker rm centos01
Error response from daemon: You cannot remove a running container 31bbf1d53e8a981548306ad055b3b40f3741ccec2daa17ed5397e0eaa1c6f48d. Stop the container before attempting removal or force remove
[root @ VM-8-3-centos docker-test-volume] # docker rm -f centos01
centos01
[root @ VM-8-3-centos docker-test-volume] # docker attach centos02
[root@4e5216b1746b volume01]# ls
abc.txt  bbb.txt

测试后发现数据依然是还在的，原则只要有一个容器还在用这个数据，数据就不会丢失。

这样可以看作是一种备份/共享机制。

原理是容器间数据卷相互拷贝。

多个mysql数据同步

先启动一个mysql01
docker run -d -p 3306:3306 -v /home/mysql01/conf:/etc/mysql/conf -v /home/mysql01/data:/var/lib/mysql --name mysql01 -e MYSQL_ROOT_PASSWORD=■■■■■■■ mysql:5.7

mysql02挂载到mysql01中

docker run -d -p 3307:3306 --name mysql02 -e MYSQL_ROOT_PASSWORD=■■■■■■■ --volumes-from mysql01 mysql:5.7

---

数据卷容器的生命周期一直持续到没有容器使用为止

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

浅入DockerFile

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

构建步骤

1、编写dockerfile
2、构建镜像：docker build -f dockerfile -t imageName:tag .
3、docker run 运行镜像，创建容器
4、 通过docker push 发布镜像（dockerhub，阿里云镜像仓库）

我们进入docker hub，查找centos，点一个他们dockerfile🔗看他们是dockerfile是怎么写的

lastest的dockerfile内容，短短4行

scratch是基础镜像，添加了centos-8-x86_64.tar.xz文件，LABEL是各种标签，CMD [“/bin/bash”]表示用bash控制台运行

FROM scratch
ADD centos-8-x86_64.tar.xz /
LABEL org.label-schema.schema-version="1.0"     org.label-schema.name="CentOS Base Image"     org.label-schema.vendor="CentOS"     org.label-schema.license="GPLv2"     org.label-schema.build-date="20201204"
CMD ["/bin/bash"]

很多官方的dockfile都是基础包，很多功能没有，那么我们就可以自己用dockerfile构建自己的镜像，比如我自己想构建一个centos + jdk + tomcat的镜像

那么dockerfile怎么写呢，用dockerfile的脚本命令，脚本命令怎么写呢？我们就需要查阅官方的文档。

基础知识：

每个保留关键字必须大写
# 表示注释

dockerfile是面向开发的，我们以后要发布项目，做镜像，需要编写dockerfile文件，编写起来十分的简单！

docker三部曲：

dockerfile -> docker images -> docker container。

我们先学会如何使用镜像和容器，接着学会如何自己编写dockerfile

dockerfile指令

FROM                        # 一起从这里开始
MAINTAINER                  # 谁写的？姓名+邮箱
RUN                         # 镜像构建时需要运行的命令
ADD                         # 如添加tomcat压缩包
WORKDIR                     # 容器工作路径
VOLUME                      # 挂载的目录
EXPOSE                      # 指定暴露端口，外部使用就不用-p了
CMD                         # 指定这个容器启动时需要执行的命令，只有最后一个会生效
ENTRYPOINT                  # 指定这个容器启动时需要执行的命令，可以追加命名
ONBUILD                     # 当构建一个被继承dockerfile时，会运行ONBUILD指令
COPY                        # 将我们文件拷贝到镜像中
ENV                         # 构建时设置环境变量，设置jvm，设置mysql密码

构建自己的dockerfile初体验

我们来升级一下centos镜像，创建一个dockerfile

FROM centos
MAINTAINER likeghee<yyz159756@163.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH

RUN yum -y install nano
RUN yum -y install net-tools

EXPOSE 80

CMD echo $MYPAH

CMD echo "---end---"

CMD /bin/bash

构建镜像
docker build -f lg-centos-dockerfile -t mycentos:0.1 .

构建完成

[root @ VM-8-3-centos dockerfile] # docker images
REPOSITORY               TAG       IMAGE ID       CREATED          SIZE
mycentos                 0.1       83c5391a2430   15 seconds ago   265MB

docker run -it --name centos01 mycentos:0.1

进入容器内测试指令

[root @ VM-8-3-centos dockerfile] # docker run -it --name centos01 mycentos:0.1

[root@fba6d42501ef local]# ls
bin  etc  games  include  lib  lib64  libexec  sbin  share  src
[root@fba6d42501ef local]# pwd
/usr/local
[root@fba6d42501ef local]# nano 1.txt

用history查看构建过程

[root @ VM-8-3-centos dockerfile] # docker history mycentos:0.1
IMAGE          CREATED         CREATED BY                                      SIZE      CO
83c5391a2430   5 minutes ago   /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "/bin…   0B
178ffa86e11f   5 minutes ago   /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "echo…   0B
98c60ef79ca0   5 minutes ago   /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "echo…   0B
5492a404f251   5 minutes ago   /bin/sh -c #(nop)  EXPOSE 80                    0B
a68f5e758ce7   5 minutes ago   /bin/sh -c yum -y install net-tools             22.7MB
5800c2d1e155   5 minutes ago   /bin/sh -c yum -y install nano                  32.6MB
8c49a72e4a69   5 minutes ago   /bin/sh -c #(nop) WORKDIR /usr/local            0B
a51e82bfb19d   5 minutes ago   /bin/sh -c #(nop)  ENV MYPATH=/usr/local        0B
fcaa00c01d7d   5 minutes ago   /bin/sh -c #(nop)  MAINTAINER likeghee<yyz15…   0B
300e315adb2f   7 weeks ago     /bin/sh -c #(nop)  CMD ["/bin/bash"]            0B
<missing>      7 weeks ago     /bin/sh -c #(nop)  LABEL org.label-schema.sc…   0B
<missing>      7 weeks ago     /bin/sh -c #(nop) ADD file:bd7a2aed6ede423b7…   209MB

CMD和ENTRYPOINT区别

制作dockerfile，创建镜像，创建容器，容器会执行命令ls -a

FROM centos
CMD ["ls", "-a"]

用CMD不能追加命令，下面指令中 -l代替了ls -a

docker run mycentos -l

再制作一个dockerfile，创建镜像，创建容器

FROM centos
ENTRYPOINT ["ls", "-a"]

用ENTRYPOINT 可以追加命令，下面指令中 创建容器，容器执行ls -al指令
docker run mycentos -l

构建自己的tomcat镜像

1、 准备镜像文件

我们需要tomcat.tar.gz和jdk.tar.gz，我们就分别去官网下载

进入官网下载tomcat安装包https://tomcat.apache.org/download-90.cgi

再去java官网下载jdk8
https://www.oracle.com/java/technologies/javase/javase-jdk8-downloads.html

通过filezilla传过来

创建Dockerfile文件，官方命名Dockerfile，就不需要-f指定文件名了

FROM centos
MAINTAINER likeghee<233>

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

# 使用ADD命令会自动帮我们解压
ADD apache-tomcat-9.0.41.tar.gz /usr/local/
ADD jdk-8u281-linux-x64.tar.gz /usr/local/

RUN yum -y install nano

ENV MYPATH /usr/local
WORKDIR $MYPATH

# 配置java环境
ENV JAVA_HOME /usr/local/jdk1.8.0_281
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

# 配置Tomcat环境
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.41
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.41

# 配置到环境变量中
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE 8080

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

写完dockerfile，build构建镜像

[root @ VM-8-3-centos build_tomcat] # docker build -t diytomcat .
Sending build context to Docker daemon  155.2MB
Step 1/15 : FROM centos
 ---> 300e315adb2f
Step 2/15 : MAINTAINER likeghee<233>
 ---> Running in 1c5019f9bc34
Removing intermediate container 1c5019f9bc34
 ---> e19fa99fde6b
Step 3/15 : COPY readme.txt /usr/local/readme.txt
 ---> 179c9dacb307
Step 4/15 : ADD apache-tomcat-9.0.41.tar.gz /usr/local/
 ---> 0097ef32b966
Step 5/15 : ADD jdk-8u281-linux-x64.tar.gz /usr/local/
 ---> 0a5d28eb6dc5
Step 6/15 : RUN yum -y install nano
 ---> Running in 005feefd9754
CentOS Linux 8 - AppStream                      5.4 MB/s | 6.3 MB     00:01

启动镜像
docker run -d -p 8080:8080 --name mytomcat01 -v /home/mytomcat01/webapps:/usr/local/apache-tomcat-9.0.41/webapps -v /home/mytomcat01/logs:/usr/local/apache-tomcat-9.0.41/logs diytomcat

docker exec -it mytomcat01 /bin/bash

测试访问，有正确的主页，OK没问题！

由于项目部署地址做了挂载-v /home/mytomcat01/webapps:/url/local/apache-tomcat-9.0.41/webapps，我们直接在linux主机/home/mytomcat01/webapps就可以部署项目了

测试发布，在webapps下新建/test/WEB-INF/web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
</web-app>

在webapps下下新建/test/index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <script src="http://libs.baidu.com/jquery/1.7.2/jquery.min.js"></script>
  Test is ok!
  <%System.out.println("hello,tomcat~");  %>
  <body>
  </body>
</html>

访问测试

查看日志，我配置的日志名字是catalina.out，在linux主机直接查看

[root @ VM-8-3-centos home] # cd mytomcat01/
[root @ VM-8-3-centos mytomcat01] # ls
logs  webapps
[root @ VM-8-3-centos mytomcat01] # cd logs/
[root @ VM-8-3-centos logs] # ls
catalina.2021-01-26.log  host-manager.2021-01-26.log  localhost_access_log.2021-01-26.txt
catalina.out             localhost.2021-01-26.log     manager.2021-01-26.log
[root @ VM-8-3-centos logs] # cat catalina.out
     1  26-Jan-2021 13:12:24.033 INFO [main] org.apache.catalina.startup.VersionLoggerListener.log Server version name:   Apache Tomcat/9.0.41
	...
    30  hello,tomcat~
    31  hello,tomcat~
    32  hello,tomcat~
    33  hello,tomcat~
    34  hello,tomcat~
    35  hello,tomcat~

发布镜像到DockerHub（基本不成功）

进入官方，注册账号https://registry.hub.docker.com/

可以看看官方的tutorial
https://www.docker.com/101-tutorial

进行登陆
docker login -u username

[root @ VM-8-3-centos logs] # docker login -u likeghee
Password:
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store

Login Succeeded

给自己的镜像加一个版本号

[root @ VM-8-3-centos home] # docker tag diytomcat diytomcat:1.0
[root @ VM-8-3-centos home] #
[root @ VM-8-3-centos home] #
[root @ VM-8-3-centos home] # docker images
REPOSITORY               TAG       IMAGE ID       CREATED          SIZE
diytomcat                1.0       83ab5d69c4e3   53 minutes ago   614MB

docker push name:tag
多半是发不上去的，还是用镜像hub吧

[root @ VM-8-3-centos home] # docker push diytomcat:1.0
The push refers to repository [docker.io/library/diytomcat]
76135d7faff6: Retrying in 1 second
b458e266c7ff: Preparing
2670babd3976: Preparing
6b0422936ccd: Preparing
2653d992f4ef: Preparing
denied: requested access to the resource is denied

发布镜像到腾讯云dockerhub

因为我的服务器在腾讯云，所以用腾讯云的容器服务

先创建一个命名空间likeghee01

创建镜像名字diytomcat

文档了找半天，终于找到了：腾讯云镜像仓库使用文档

我们只要点进仓库后，点使用指引，复制粘贴照着做就行

跟着文档操作走就行

[root @ VM-8-3-centos ~] # sudo docker tag 83ab5d69c4e3  ccr.ccs.tencentyun.com/likeghee01/diytomcat:1.0
[root @ VM-8-3-centos ~] # sudo docker push ccr.ccs.tencentyun.com/likeghee01/diytomcat:1.0
The push refers to repository [ccr.ccs.tencentyun.com/likeghee01/diytomcat]
76135d7faff6: Mounted from likeghee01/cangku1
b458e266c7ff: Mounted from likeghee01/cangku1
2670babd3976: Mounted from likeghee01/cangku1
6b0422936ccd: Mounted from likeghee01/cangku1
2653d992f4ef: Mounted from likeghee01/cangku1
1.0: digest: sha256:23e2552ee6ebf530bed3821398afa585ba61e7319a8dd2896864fe46f5e2c6f6 size: 1373

上传成功，F5查看一下结果

拉取测试一下

sudo docker pull ccr.ccs.tencentyun.com/likeghee01/diytomcat:1.0

[root @ VM-8-3-centos ~] # sudo docker pull ccr.ccs.tencentyun.com/likeghee01/diytomcat:1.0
1.0: Pulling from likeghee01/diytomcat
7a0437f04f83: Pull complete
225de9ea2424: Pull complete
f95bb4098f3a: Pull complete
51d7bacd9c8c: Pull complete
926b04ec50e3: Pull complete
Digest: sha256:23e2552ee6ebf530bed3821398afa585ba61e7319a8dd2896864fe46f5e2c6f6
Status: Downloaded newer image for ccr.ccs.tencentyun.com/likeghee01/diytomcat:1.0
ccr.ccs.tencentyun.com/likeghee01/diytomcat:1.0

看一下拉取结果，OK

[root @ VM-8-3-centos ~] # docker images
REPOSITORY                                    TAG       IMAGE ID       CREATED       SIZE
ccr.ccs.tencentyun.com/likeghee01/diytomcat   1.0       83ab5d69c4e3   2 hours ago   614MB

docker操作全流程

再来看一次这些指令，是不是觉得so easy了

save和load是将镜像打包成jar，便于发送给别人，但是一般做法都是直接去仓库拉取就好了，save被用来备份了

---

================

| docker入坟分界线 |

================

---

欢迎来到容器互联世界，真正的学习在这后面，前面都只是基础。

真正能做事情的东西是下面这三个。

Docker Compose

Docker Swarm

CI/CD Jenkins

好嘞，按捺住删库跑路的心情

docker rm -f $(docker ps -aq)
docker rmi -f $(docker images -aq)

继续往死里学。

Docker网络

什么是docker0？

输入ip addr，你会看见我们熟悉的网络配置，lo本机回环地址，eth0以太网网卡，但docker0又是什么呢？

1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host
       valid_lft forever preferred_lft forever
       
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 52:54:00:16:7f:10 brd ff:ff:ff:ff:ff:ff
    inet 10.0.8.3/22 brd 10.0.11.255 scope global eth0
       valid_lft forever preferred_lft forever
    inet6 fe80::5054:ff:fe16:7f10/64 scope link
       valid_lft forever preferred_lft forever
       
3: docker0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default
    link/ether 02:42:0f:e4:02:1a brd ff:ff:ff:ff:ff:ff
    inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0
       valid_lft forever preferred_lft forever
    inet6 fe80::42:fff:fee4:21a/64 scope link
       valid_lft forever preferred_lft forever

docker0是docker为我们生成的网卡。docker0分配的地址是 172.17.0.1

inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0

docker是如何处理容器网络访问的？tomcat容器中项目如何访问另一个mysql容器项目呢？kabana连接es的原理是什么？这是在学习过程中自然而然就引出的问题。

我们先放一放

我们先把tomcat运行起来
docker run -d --name tomcat01 tomcat

传递命令查看ip地址
docker exec -it tomcat01 ip addr

[root @ VM-8-3-centos ~] # docker exec -it tomcat01 ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
98: eth0@if99: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default
    link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever

启动后发现容器有一个98: eth0@if99地址，这个地址是172.17.0.2，是docker给容器分配的。

如果我们直接再主机ping通，那容器内和主机就能直接交互，172.17.0.1和172.17.0.2在同一网段应该能ping通的，我们就来验证自己的猜想

ping 172.17.0.2

成功ping通了，说明主机能和容器内交互

[root @ VM-8-3-centos ~] # ping 172.17.0.2
PING 172.17.0.2 (172.17.0.2) 56(84) bytes of data.
64 bytes from 172.17.0.2: icmp_seq=1 ttl=64 time=0.060 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.043 ms

我们在主机再ip addr一次，发现主机多了一个 99:veth08a04d1@if98网卡，这和容器内的98: eth0@if99网卡惊人的疑似，根据命名，我们可以推断这是一个相互配置互相绑定的网络。

99: veth08a04d1@if98: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master docker0 state UP group default
    link/ether 4a:86:0c:30:b7:f5 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet6 fe80::4886:cff:fe30:b7f5/64 scope link
       valid_lft forever preferred_lft forever

那再思考容器a 去 ping 容器b能ping通吗？

我们再启动tomcat2
docker run -d --name tomcat02 tomcat

我们再ip addr，发现又多了一个网卡 101: veth441f03c@if100

101: veth441f03c@if100: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master docker0 state UP group default
    link/ether 8e:ae:b4:f1:88:e9 brd ff:ff:ff:ff:ff:ff link-netnsid 1
    inet6 fe80::8cae:b4ff:fef1:88e9/64 scope link
       valid_lft forever preferred_lft forever

查看容器2的ipconf
docker exec -it tomcat02 ip addr

此时，docker给容器2分配ip地址172.17.0.3

100: eth0@if101: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default
    link/ether 02:42:ac:11:00:03 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.17.0.3/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever

自然地，我们可以得出结论，每启动一个容器，docker就会给容器分配一个ip。并且主机和容器的网卡是成对的配置的

查阅资料后，发现这种成对配置网卡技术是veth-pair技术，能够连接一对虚拟设备接口。

veth-pair 就是一对的虚拟设备接口，和 tap/tun 设备不同的是，它都是成对出现的。一端连着协议栈，一端彼此相连着

正是因为这个技术，linux主机和各容器间搭建了桥梁，根据veth-pair的通信协议，两个虚拟的接口就可以相互通信了。

那容器1和容器2之间可以ping通吗？
172.17.0.2和172.17.0.3在同一个网段自然应该是可以ping通的，我们来实验。
docker exec -it tomcat02 ping 172.17.0.2

答案是肯定的

[root @ VM-8-3-centos ~] # docker exec -it tomcat02 ping 172.17.0.2
PING 172.17.0.2 (172.17.0.2) 56(84) bytes of data.
64 bytes from 172.17.0.2: icmp_seq=1 ttl=64 time=0.082 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.062 ms
64 bytes from 172.17.0.2: icmp_seq=3 ttl=64 time=0.050 ms
64 bytes from 172.17.0.2: icmp_seq=4 ttl=64 time=0.060 ms

结论：容器间是可以相互ping通的

容器间通信原理：容器都与linux主机通过veth-pair桥接，容器间用主机作为路由器来转发进行通信。

也就是说，容器a想访问容器b，过程是：容器a发送数据报给linux主机，linux主机再转发给容器b。

所有容器不指定网络的情况下，都是由docker0路由的，docker会为容器分配可用ip。

我们复习一下计网知识，172.17.0.3/16，这个网段能分配多少个ip呢？，16是掩码，说明前16位固定，可分配空间是后16位，可分配空间大小位：2^16-2，减去回环地址和广播地址

docker0和物理网卡应该是直连的NAT，容器和docker0用veth-pair相连

容器互联 --link

我们每次启动容器ip分配是随机的，因此在web项目中我们不能将容器的ip写死

好在docker为我们提供了–link解决这样的问题。

先启动两个tomcat
docker run -d --name tomcat01 tomcat
docker run -d --name tomcat02 tomcat

我可以通过link指令，将ip与容器关联

我们将容器3与容器2相连
docker run -d --name tomcat03 --link tomcat02 tomcat

我们就可以直接用tomcat02作为ip，docker帮我们做了映射，我们测试一下。

[root @ VM-8-3-centos ~] # docker exec -it tomcat03 ping tomcat02
PING tomcat02 (172.17.0.3) 56(84) bytes of data.
64 bytes from tomcat02 (172.17.0.3): icmp_seq=1 ttl=64 time=0.071 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=2 ttl=64 time=0.049 ms

以后我们直接些服务名就可以了，不用将IP写死。

反向可以ping通吗？

不可以，因为容器2的路由表没有容器3的名字与ip映射

查看网络
docker network ls

[root @ VM-8-3-centos ~] # docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
1abd08b32583   bridge    bridge    local
aaeff81ecdc5   host      host      local
cff51a9cc81c   none      null      local

bridge 就是docker0

我们查看docker0网络元数据
docker network inspect bridge

	...
 "Created": "2021-01-26T08:38:35.539380755+08:00",
    "Scope": "local",
    "Driver": "bridge",
    "EnableIPv6": false,
    "IPAM": {
        "Driver": "default",
        "Options": null,
        "Config": [
            {
            	# 空间分配大小2^16
                "Subnet": "172.17.0.0/16",
                # 网关 docker0
                "Gateway": "172.17.0.1"
            }
        ]
    },

	...
 "ConfigOnly": false,
 		# 为容器分配的ip
        "Containers": {
            "26f956e921672476388424bf35813f4387e8342dbcd81d9d38baaae11931f5eb": {
                "Name": "tomcat01",
                "EndpointID": "33ae22cf665763e9007e383e7bde6b49f75a524b642370464cbe34df0e681e82",
                "MacAddress": "02:42:ac:11:00:02",
                "IPv4Address": "172.17.0.2/16",
                "IPv6Address": ""
            },
            "5628a29c35260e651945cf1b6d02a27aea17c42c00b17ed577501ff476ea298e": {
                "Name": "tomcat03",
                "EndpointID": "2bc7404467a982154690f6ef9abd3330155f1c0420da9523e4787b6047805aa9",
                "MacAddress": "02:42:ac:11:00:04",
                "IPv4Address": "172.17.0.4/16",
                "IPv6Address": ""
            },
            "5b013d01ba6e10a6edc6266c46e7c1bbd88884e43b1edaf1de2d703ebfc2b0a6": {
                "Name": "tomcat02",
                "EndpointID": "8d9aa71587196d9874181e77c7cfcb9abdea745f870a0351a078ccda8b10b3c6",
                "MacAddress": "02:42:ac:11:00:03",
                "IPv4Address": "172.17.0.3/16",
                "IPv6Address": ""
            }
        },
       
       ...后略

如何查看容器内的网络元数据呢

docker inspect tomcat03

找半天，好像看不到…

换个思路，我们直接进容器内，用指令查看
docker exec -it tomcat03 /bin/bash
cat /etc/hosts

[root @ VM-8-3-centos ~] # docker exec -it tomcat03 /bin/bash
root@5628a29c3526:/usr/local/tomcat# cat /etc/hosts
127.0.0.1       localhost
::1     localhost ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
172.17.0.3      tomcat02 5b013d01ba6e
172.17.0.4      5628a29c3526

看到tomcat02的配置了吗，tomcat02直接作为域名与tomcat02的ip关联

172.17.0.3 tomcat02 5b013d01ba6e

做到这里，内心激动，大彻大悟

–link的原理：在host的配置中增加了容器名与ip的映射

那么我想让tomcat02 --link上 tomcat03，如何操作？

我们进入tomcat02，修改host文件即可。

但是，现在这种已经过时了，我们应该目光看向更远，使用自定义网络！

---

自定义网络

docker0网络的特点，默认情况下，不能通过容器名访问，–link可以打通，但是不方便。我们可以自定义一个网络。

回到docker network ls

查看所有docker网络

NETWORK ID     NAME      DRIVER    SCOPE
1abd08b32583   bridge    bridge    local
aaeff81ecdc5   host      host      local
cff51a9cc81c   none      null      local

我们需要先了解docker默认有哪些网络

bridge：桥接模式，docker上搭桥使得linux主机能和各个容器进行通信（默认所属网络叫bridge，默认模式是bridge，名字不要混了）

none：不配置网络

host：和宿主机共享一个网络

container：容器内网络连通（使用的很少，局限性很大）

进入正题

我们可以通过docker network create创建网络

创建mynet网络，这里默认是 --driver bridge可以不写
docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

这和上面的等价
docker network create --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

[root @ VM-8-3-centos ~] # docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
...
42aeabff8ce6   mynet     bridge    local
cff51a9cc81c   none      null      local

这么配置后192.168.0.1~192.168.255.254都在一个网段，在这个网段中的容器间就随意访问

查看我们自己的网络
docker network inspect mynet

[root @ VM-8-3-centos ~] # docker network inspect mynet
[
    {
        "Name": "mynet",
        "Id": "42aeabff8ce6911daf648c250f6dad77fa25fc4c8167369189c2a75a83b63e10",
        "Created": "2021-01-27T10:55:04.156026826+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "192.168.0.0/16",
                    "Gateway": "192.168.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {},
        "Options": {},
        "Labels": {}
    }
]

我们可以通过docker run --net配置容器的所属网络，默认所属网络是bridge

启动容器，配置所属网络

docker run -d -P --name tomcat01 --net mynet tomcat

docker run -d -P --name tomcat02 --net mynet tomcat

我们再查看我们自己的网络
docker network inspect mynet

我们可以看到容器1和容器2被分配了ip和配置好了网关

"Containers": {
            "6c3aa37abb4f197bdce207e2c4191261680de62454c1f34f20ff5aec6affdfc6": {
                "Name": "tomcat02",
                "EndpointID": "1778e59c02ee7b7e71ae077225efae513db036981c0c6a0172ce15bce976733f",
                "MacAddress": "02:42:c0:a8:00:03",
                "IPv4Address": "192.168.0.3/16",
                "IPv6Address": ""
            },
            "6edc50069e268bc27094296b569dc4879ce4dff7eb37c9af94fe08a8d3c190be": {
                "Name": "tomcat01",
                "EndpointID": "6c8365dd51595a7e1623ddfdf86b6c2387e2fc948e464475ba2d746404fb7eba",
                "MacAddress": "02:42:c0:a8:00:02",
                "IPv4Address": "192.168.0.2/16",
                "IPv6Address": ""
            }
        },

这么做的好处是什么？

自定义出来的网络，容器加入网络中，有自动配置功能。

我们进行测试

docker exec -it tomcat01 ping tomcat02

我们没有配置link也能通过容器名直接ping通，这就十分的优雅了

[root @ VM-8-3-centos ~] # docker exec -it tomcat01 ping tomcat02
PING tomcat02 (192.168.0.3) 56(84) bytes of data.
64 bytes from tomcat02.mynet (192.168.0.3): icmp_seq=1 ttl=64 time=0.050 ms
64 bytes from tomcat02.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.049 ms

网络连通

现在我们已经有两个网络了，默认的docker0网络和我们自己的mynet网络，现在已经有tomcat01和tomcat02部署在mynet中了，假设docker0上又有tomcat03，怎么让在不同网络上容器相互ping通呢。

已有tomcat01和02在mynet网络中
docker run -d -P --name tomcat01 --net mynet tomcat
docker run -d -P --name tomcat02 --net mynet tomcat
再创建容器3在默认网络中
docker run -d -P --name tomcat03 tomcat

3直接去ping2，这样肯定是ping不通的
docker exec -it tomcat03 ping tomcat02

解决思路应该是容器3和mynet网卡打通，然后让mynet网关去做转发

我们可以使用docker network connect 连接一个容器到网络

[root @ VM-8-3-centos ~] # docker network connect --help

Usage:  docker network connect [OPTIONS] NETWORK CONTAINER

Connect a container to a network

Options:
      --alias strings           Add network-scoped alias for the container
      --driver-opt strings      driver options for the network
      --ip string               IPv4 address (e.g., 172.30.100.104)
      --ip6 string              IPv6 address (e.g., 2001:db8::33)
      --link list               Add link to another container
      --link-local-ip strings   Add a link-local address for the container

容器3加入到mynet网络中
docker network connect mynet tomcat03

再ping一次，可以ping通了，这么一来网络间就打通了

[root @ VM-8-3-centos ~] # docker exec -it tomcat03 ping tomcat02

PING tomcat02 (192.168.0.3) 56(84) bytes of data.
64 bytes from tomcat02.mynet (192.168.0.3): icmp_seq=1 ttl=64 time=0.058 ms
64 bytes from tomcat02.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.049 ms

原理是什么？

查看网络mynet元数据，tomcat03加入到了网段中，用官方文档中的话来说就是一个容器两个ip

    "ConfigFrom": {
        "Network": ""
    },
    "ConfigOnly": false,
    "Containers": {
        "6c3aa37abb4f197bdce207e2c4191261680de62454c1f34f20ff5aec6affdfc6": {
            "Name": "tomcat02",
            "EndpointID": "1778e59c02ee7b7e71ae077225efae513db036981c0c6a0172ce15bce976733f",
            "MacAddress": "02:42:c0:a8:00:03",
            "IPv4Address": "192.168.0.3/16",
            "IPv6Address": ""
        },
        "6edc50069e268bc27094296b569dc4879ce4dff7eb37c9af94fe08a8d3c190be": {
            "Name": "tomcat01",
            "EndpointID": "6c8365dd51595a7e1623ddfdf86b6c2387e2fc948e464475ba2d746404fb7eba",
            "MacAddress": "02:42:c0:a8:00:02",
            "IPv4Address": "192.168.0.2/16",
            "IPv6Address": ""
        },
        "c6fef48e5c65d27c1ae4111a4e5478d29151f6fe15340a58b0f8e6f1831d3374": {
            "Name": "tomcat03",
            "EndpointID": "3e1941d32f8f81c1dd3b872f0d5597188cbb83e2a9a24bbbf08a1fc6c5e0e49d",
            "MacAddress": "02:42:c0:a8:00:04",
            "IPv4Address": "192.168.0.4/16",
            "IPv6Address": ""
        }
    },

部署redis集群

摸了

部署springboot

摸了