docker搭建学习笔记

以下笔记来自B站狂胜教学：
感谢狂神的教学视频
1、docker的出现解决了什么问题？
首先，一个项目的上线，离不开开发和运维。Docker将两者连接起来，开发人员在docker上，将项目带上环境安装打包。运维直接通过去下载镜像，直接运行即可。做到开发打包部署上线，一套流程做完。
Docker官网

从上面的图标可看都，小鲸鱼上面有很多集装箱。Docker的核心就来自于集装箱，集装箱之间相互隔离，正是通过这种隔离机制将服务器利用到极致。
有兴趣可以去，docker发展历史，是一个有趣的发展过程。

docker官方文档这个文档很重要，因为docker官方文档很详细。
要有一个概念，docker是容器化技术，不是模拟一个完整的操作系统。如下一个容器你就可以看成一个微服务。

对比虚拟机和docker:
虚拟机 ：在windows中安装VM，通过这个软件可以模拟出来一台或者很多台电脑！十分笨重，每次相当于一个新的电脑，需要的东西都要自己安装。而且一般需要几个G,甚至更大。

docker : 是一种容器技术，他也是虚拟化技术。是隔离、镜像（最核心的环境 4M+JDK + mysql）十分轻巧。直接运行镜像就可以了。而且内存占用较小，一般几兆或者更低。启动也很快，可以说秒级启动。

docker的优点：
1、容器内的应用直接运行在宿主机的内容，容器是没有自己的内核的，也没有虚拟我们需要的硬件，所以更加轻便。
2、每个容器相互隔离，每个容器内都有属于自己的文件系统，互不影响。

**DevOps（开发、运维）**这个词作为程序人并不陌生。

• 应用更快速的交付和部署，docker打包镜像发布测试，一键运行。
• 更便捷的升级和扩缩容。使用docker后，就像搭积木，将容器堆积即可
• 容器化后，我们的开发，测试环境和开发环境高度一致。
• 更高效的计算资源利用。同一个物理机上运行很多的容器实例。将服务器的性能压榨到极致。

Docker的基本的组成：

几个重要的概念：
镜像 ： 就好比是一个模板，可以通过这个模板来创建容器服务，比如tomcat --run --tomcat1容器。通过这个镜像创建多个多个容器（最终服务运行或项目运行就在容器中）。
容器 ： docker利用容器技术，独立运行一个或一组应用，通过镜像来创建的。它涉及启动，停止，删除等基本的命令。
仓库 ：仓库就是存放镜像的地方。仓库分为共有仓库和私有仓库。

下载安装docker：环境准备，新建一个全新的VM，克隆原有镜像即可。
查看版本：

root@ubuntu:/# uname -r
4.15.0-48-generic
root@ubuntu:/# cat /etc/os-release 
NAME="Ubuntu"
VERSION="16.04.6 LTS (Xenial Xerus)"
ID=ubuntu
ID_LIKE=debian
PRETTY_NAME="Ubuntu 16.04.6 LTS"
VERSION_ID="16.04"
HOME_URL="http://www.ubuntu.com/"
SUPPORT_URL="http://help.ubuntu.com/"
BUG_REPORT_URL="http://bugs.launchpad.net/ubuntu/"
VERSION_CODENAME=xenial
UBUNTU_CODENAME=xenial

上面版本是支持的：

基本环境问题：安装基本的yum,vim等
1、确保能连接网络。

2、XShell能连接上。如果报错ssh拒绝服务器拒绝密码。这是因为sshd的设置不允许root用户用密码远程登录。

vim /etc/ssh/sshd_config 

修改配置为:

PermitRootLogin yes

重启：

root@ubuntu:/# /etc/init.d/ssh restart
[ ok ] Restarting ssh (via systemctl): ssh.service.

即可连接上Xshell:

遇到的报错解决: 发现vim不能安装，确认是否有进程正在占用apt

root@ubuntu:/# sudo apt-get update
Reading package lists... Done
E: Could not get lock /var/lib/apt/lists/lock - open (11: Resource temporarily unavailable)
E: Unable to lock directory /var/lib/apt/lists/
root@ubuntu:/# ps -e|grep apt
  1385 ?        00:00:00 apt.systemd.dai
  1396 ?        00:00:00 apt.systemd.dai
  1458 ?        00:00:00 apt-get
  2325 ?        00:00:01 aptd
root@ubuntu:/# killall aptd
root@ubuntu:/# killall apt.systemd.dai
apt.systemd.dai: no process found
root@ubuntu:/# killall apt-get
root@ubuntu:/# ps -e|grep apt
  2325 ?        00:00:02 aptd
root@ubuntu:/# killall aptd
root@ubuntu:/# ps -e|grep apt

在更新就可以了。

apt-get update
apt-get install vim

装备好环境后，我们按照官网的环境一步步安装：
1、卸载旧版本

root@ubuntu:~# sudo apt-get remove docker docker-engine docker.io containerd runc

2、使用存储库安装
更新apt软件包索引并安装软件包以允许apt通过HTTPS使用存储库：

apt-get update

apt-get install \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg-agent \
    software-properties-common

添加Docker的官方GPG密钥：

root@ubuntu:~# curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

确保key安装：

root@ubuntu:~# apt-key fingerprint 0EBFCD88
pub   4096R/0EBFCD88 2017-02-22
      Key fingerprint = 9DC8 5822 9FC7 DD38 854A  E2D8 8D81 803C 0EBF CD88
uid                  Docker Release (CE deb) <docker@docker.com>
sub   4096R/F273FCD8 2017-02-22

设置稳定的存储库：

add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
   $(lsb_release -cs) \
   stable"

最新版本的Docker Engine和容器：

apt-get install docker-ce docker-ce-cli containerd.io

测试安装是否成功：
启动，并docker version，查看是否成功。

root@ubuntu:~# systemctl start docker
root@ubuntu:~# docker version

测试：

docker run hello-world

此命令下载测试图像并在容器中运行。容器运行时，它会打印参考消息并退出。
测试结果：

root@ubuntu:~# docker run hello-world
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world  # pull拉取hello-world镜像
0e03bdcc26d7: Already exists 
Digest: sha256:49a1c8800c94df04e9658809b006fd8a686cab8028d33cfba2cc049724254202
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/

如果要卸载Docker
卸载Docker Engine，CLI和Containerd软件包：

$ sudo apt-get purge docker-ce docker-ce-cli containerd.io

主机上的映像，容器，卷或自定义配置文件不会自动删除。要删除所有图像，容器和卷：

$ sudo rm -rf /var/lib/docker # 默认工作路径

您必须手动删除所有已编辑的配置文件。

注意：如果你有阿里云或者其他云。可以配置阿里云或其他云镜像加速器。本人没有这里不介绍。

分析hello-world的运行流程：

docker的原理：
Docker是一个CS结构的系统，Docker的守护进程运行在主机上，通过Socket从客户端访问
当DockerServer接收到Docker-Client的指令时，就会执行这个命令。

docker为什么比虚拟机快？
来自：编程加油

docker常用命令（重要）
命令文档地址
以下截图只是为了说明位置，不全。

docker version # 显示版本信息
docker info # 显示docker的系统信息
docker --help # 帮助命令

root@ubuntu:~# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
hello-world         latest              bf756fb1ae65        7 months ago        13.3kB
# REPOSITORY(镜像的仓库hello-world) 、TAG (镜像标签latest) 、IMAGE ID(镜像id bf756fb1ae65) CREATED(创建时间7 months ago) SIZE(大小 13.3kB)

docker images -a # 列出所有镜像
docker images -q # 只显示镜像id 一般合用-aq

镜像搜索：
方式一：官网直接搜索
方式二：命令搜索（结果为列表）

root@ubuntu:~# docker search mysql
 # 可以指定过滤器
root@ubuntu:~# docker search mysql --filter=STARS=5000
NAME                DESCRIPTION                                     STARS               OFFICIAL            AUTOMATED
mysql               MySQL is a widely used, open-source relation…   9793                [OK]   

镜像下载：

# 语法 docker pull 镜像名[:tag]
root@ubuntu:/etc/docker# docker pull mysql
Using default tag: latest # 不写默认拉取最新的
latest: Pulling from library/mysql
6ec8c9369e08: Pull complete  // 分层下载。比如一个一下再的在下载另一个版本，很多层可以不用在下载。---联合文件系统
177e5de89054: Pull complete 
ab6ccb86eb40: Pull complete 
e1ee78841235: Pull complete 
09cd86ccee56: Pull complete 
78bea0594a44: Pull complete 
caf5f529ae89: Pull complete 
cf0fc09f046d: Pull complete 
4ccd5b05a8f6: Pull complete 
76d29d8de5d4: Pull complete 
8077a91f5d16: Pull complete 
922753e827ec: Pull complete 
Digest: sha256:fb6a6a26111ba75f9e8487db639bc5721d4431beba4cd668a4e922b8f8b14acc   # 签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest  // 真实地址


#指定版本，一定要是docker官网有指定的版本。
docker pull mysql:5.7 

国外实在太慢了。修改镜像地址：（如下方法保证docker最新）
镜像地址有很多的。自己百度一个或几个放进去。

vim /etc/docker/daemon.json

# 输入退出保存
{ 
"registry-mirrors": ["https://registry.docker-cn.com","http://hub-mirror.c.163.com"] 
}

# 重新加载daemon
systemctl daemon-reload

# 重启服务
systemctl restart docker

# 可以看到镜像已经改变
docker info
systemctl status docker # 启动状态查询

结果查看：

删除镜像：根据image id或名字删除。

root@ubuntu:/etc/docker# docker rmi -f  8679ced16d20
Untagged: mysql:5.7
Untagged: mysql@sha256:97869b42772dac5b767f4e4692434fbd5e6b86bcb8695d4feafb52b59fe9ae24
Deleted: sha256:8679ced16d206961b35686895b06cfafefde87ef02b518dfc2133081ebf47cda
Deleted: sha256:355f87dc5125a32cc35898a4dde17fb067585bc0d86704b5a467c0ccc0eea484
Deleted: sha256:8299d5c38042216210125535adb2600e46268a0e2b9ec799d12ea5b770236e79
Deleted: sha256:07311a303b2c7cf2ac6992aaf68e12326fe7255985166939cbab7d18b10e0f47
Deleted: sha256:306c9bc1ce2997d000bb6f1ea4108420d9752df93ce39164b7a2f876b954afc4

常用命令

# 删除指定镜像
docker rmi -f  8679ced16d20
# 删除多个镜像
docker rmi -f  8679ced16d20 镜像id1 镜像id2
# 删除所有
docker rmi -f  $(docker images -aq)

容器命令
首先我们，我们要有了镜像才能创建容器，下载一个centos来测试。

root@ubuntu:/etc/docker# docker pull centos

新建容器并启动：

docker run [可选] image
 # 参数名 --name="Name" 容器名字 tomcat01 tomcat02 用来区分容器
 		 -d 后台方式运行
 		 -it 使用交互方式运行，进入容器查看内容
 		 -p 指定容器端口 -p 8080:8080
 		 -P 随机指定端口

测试启动/退出：

root@ubuntu:/etc/docker# docker run -it centos /bin/bash
# 下面可以看到目录结构是一样的。
[root@3f5a1314ed3a /]# ls
bin  etc   lib	  lost+found  mnt  proc  run   srv  tmp  var
dev  home  lib64  media       opt  root  sbin  sys  usr
# 退出容器并关闭
[root@3f5a1314ed3a /]# exit
exit

ctrl+p+q # 容器不停止退出

容器基础命令：

docker ps # 列出所有的容器
docker ps -a # 列出当前正在运行的容器
docker ps -q  # 只显示容器的编号
docker ps -n=?  # 最近？天创建的容器

# 删除容器
docker rm -f 容器id # 删除指定容器
docker rm -f $(docker ps -aq) # 删除所有容器

# 启动/停止容器
docker start 容器id
docker restart 容器id  #重启
docker stop 容器id     # 停止容器
docker kill 容器id     # 停止容器

常用其他命令：
这个docker run -d centos 的坑，docker容器使用后台运行，就必须要有一个前台进程。如果发现没有应用，则会自动停止。

查看日志（如果没有自己写shell脚本触发）

docker logs -tf --tail 10 容器id # 显示10条

查看容器内的进程：

root@ubuntu:/etc/docker# docker run -it centos /bin/bash
[root@0349afe70444 /]# root@ubuntu:/etc/docker# docker top 0349afe70444
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                112347              112322              0                   09:33               pts/0               00:00:00            /bin/bash

查看镜像元数据：

# 0349afe70444 容器id
root@ubuntu:/etc/docker# docker inspect 0349afe70444
[
    {
        "Id": "0349afe704445232eec430bc9ece5f0319cf75fd8d275da0125479a883eb7bc2",
        "Created": "2020-08-04T16:33:04.090963833Z",
        "Path": "/bin/bash",
        "Args": [],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 112347,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2020-08-04T16:33:05.19047918Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:831691599b88ad6cc2a4abbd0e89661a121aff14cfa289ad840fd3946f274f1f",
        "ResolvConfPath": "/var/lib/docker/containers/0349afe704445232eec430bc9ece5f0319cf75fd8d275da0125479a883eb7bc2/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/0349afe704445232eec430bc9ece5f0319cf75fd8d275da0125479a883eb7bc2/hostname",
        "HostsPath": "/var/lib/docker/containers/0349afe704445232eec430bc9ece5f0319cf75fd8d275da0125479a883eb7bc2/hosts",
        "LogPath": "/var/lib/docker/containers/0349afe704445232eec430bc9ece5f0319cf75fd8d275da0125479a883eb7bc2/0349afe704445232eec430bc9ece5f0319cf75fd8d275da0125479a883eb7bc2-json.log",
        "Name": "/quirky_mendel",
        "RestartCount": 0,
        "Driver": "overlay2",
        "Platform": "linux",
        "MountLabel": "",
        "ProcessLabel": "",
        "AppArmorProfile": "docker-default",
        "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,
            "Capabilities": null,
            "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/dc5d718b2567e072dfb99ff4b370695590709e970489063ff1c1f25ee47777df-init/diff:/var/lib/docker/overlay2/575083deb7d9c6b50ed1eed0d9ccaa5a52d1ea8e6fbe5f49d67ac789b65c11d7/diff",
                "MergedDir": "/var/lib/docker/overlay2/dc5d718b2567e072dfb99ff4b370695590709e970489063ff1c1f25ee47777df/merged",
                "UpperDir": "/var/lib/docker/overlay2/dc5d718b2567e072dfb99ff4b370695590709e970489063ff1c1f25ee47777df/diff",
                "WorkDir": "/var/lib/docker/overlay2/dc5d718b2567e072dfb99ff4b370695590709e970489063ff1c1f25ee47777df/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [], # 挂载
        "Config": {
            "Hostname": "0349afe70444",
            "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": "20200611",
                "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": "c488c3b795c8a40628d90788a08732f468f40fc902b668f42f39ee5ca46081bf",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/c488c3b795c8",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "b3d24302745412cd871b5a3dcf6726104e1c9f9133f11662fbfa2caafb38e12f",
            "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": "12a6e9b23cb7af472fc04e41d8407e94479841f7a67f5571fca9881bc00a81c0",
                    "EndpointID": "b3d24302745412cd871b5a3dcf6726104e1c9f9133f11662fbfa2caafb38e12f",
                    "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@ubuntu:/etc/docker# docker attach 0349afe70444
[root@0349afe70444 /]# 
# 方式二 。 这个可操作
root@ubuntu:/etc/docker# docker exec -it 0349afe70444 /bin/bash
[root@0349afe70444 /]# 

移动文件（将容器内的文件拷到外面）：

docker cp 容器id:文件目录 外部文件目录

docker的命令很多啊！ 一口吃不了大胖子。后面慢慢积累。
官方所有命令框架图：

docker安装nginx
官网搜索

点击去就可以看到如何拉取，如何跑起来：（以下没有必要，命令结果不给出）
拉取：

root@ubuntu:/etc/docker# docker pull nginx

启动：(官网有很多种启动命令自己查看,这个启动命令很复杂的)

 docker run --name some-nginx -d -p 3344:80 nginx

这句命令是暴露外部端口然后，您可以在浏览器中点击http://localhost:8080或http://host-ip:8080。也就是通过公网的3344可以访问到nginx的80.（不要占用8080）
端口暴露的概念：

查看结果：成功启动

root@ubuntu:/etc/docker# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                  NAMES
c12864e31d4e        nginx               "/docker-entrypoint.…"   20 seconds ago      Up 18 seconds       0.0.0.0:8080->80/tcp   some-nginx
0349afe70444        centos              "/bin/bash"              31 minutes ago      Up 30 minutes                              quirky_mendel

模拟请求测试：

root@ubuntu:/etc/docker# 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>

window访问结果：这个任何人都可以访问了。

docker安装tomcat
一样官网搜索，查看版本、安装、启动等命令。不一一截图。

docker run -it --rm tomcat:9.0  # --rm 用完即删除，适用于测试
# 如果需要外部访问需要端口映射
docker run -it --rm -p 8888:8080 tomcat:9.0
# 上面两个命令都是先去判断本机已有?没有下载并启动，有直接启动

访问测试：确实404。不截图。
官方说明：您可以转到http://localhost:8888或http://host-ip:8888在浏览器中（请注意，由于默认情况下未加载任何Web应用，因此它将返回404）。
也就是webapps目录下是空的。这是因为阿里云默认最小镜像，将不必要的全部删除。

docker安装 es+kibana
特点：es暴露端口多、十分消耗内存、数据要放在安全目录、网络配置。
一样的过程官网搜索。
官网的相关介绍：
什么是Elasticsearch？
Elasticsearch是一个分布式的RESTful搜索和分析引擎，能够解决越来越多的用例。作为Elastic Stack的核心，它集中存储您的数据，以便您发现期望的数据并发现意外的数据。
[相关官网]的详细介绍(https://www.elastic.co/guide/en/elasticsearch/reference/7.5/docker.html)
在开发模式下运行，创建用户定义的网络（用于连接到连接到同一网络的其他服务（例如，Kibana））：

$ docker network create somenetwork

运行Elasticsearch：

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

这里先不配置network: 这个东西是真的难pull下来，retry了n次也拉不下啦。放弃啦。

docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.8.1

可视化Rancher(CI/CD)：Rancher是一个容器管理平台,通过Rancher可以实现Docker和Kubernetes的轻松部署。

镜像如此重要，它有必要细细理解。
镜像是一种轻量级、可执行独立软件包，用来打包软件运行环境和基于运行环境开发的软件。它包含运行某个软件所需要的所有内容，包括代码、运行时库、环境变量、配置文件等。所有的应用直接打包docker镜像，就可以直接跑起来。
Docker镜像的加载原理：前面pull时，我们可以看到就是分层下载（联合文件系统）

如何提交自己的镜像：

# docker commit  提交一个容器成为一个新的副本
docker commit -m="提交描述" -a="author" 容器id 目标镜像名:[tag]

比如上面我们tomcat访问是404。我们将修改后作为tomcat1.0版本。

首先将 webapps.dist目录下文件复制到webapps目录下

root@bef02c8f8f49:/usr/local/tomcat# cp -r webapps.dist/* webapps/
root@bef02c8f8f49:/usr/local/tomcat# cd webapps
root@bef02c8f8f49:/usr/local/tomcat/webapps# ls
ROOT  docs  examples  host-manager  manager

cp -r webapps.dist webapps和cp -r webapps.dist/* webapps/ 或 cp -r webapps.dist/. webapps/注意这两个命令区别，一个是将文件夹复制过去，一个是将文件下内容复制过去。
window下访问成功：

那么我们这个版本作为tomcat1.0。

root@ubuntu:~# docker commit -a="tomcat version 1.0" -a="zhouyi" bef02c8f8f49 tomcat02:v1.0

结果：可以看到就是我们创建的一个v1.0版本的tomcat02的镜像。这也是分层的好处。

容器数据卷（重要）：
本质是目录的挂载，将我们的容器的内容，挂载到Linux上。目的就是为了容器的持久化以及容器间数据共享。
比如：mysql容器种数据持久化操作。

挂载命令： - v

# docker run -it -v 主机目录:容器目录
# 比如我们将centos下home挂载到主机/home/test下
docker run -it -v /home/test:/home centos
# 查看容器信息
docker inspect cbf0c08506e3

结果：

挂载（持久化）成功：

那么来讲数据库mysql的数据挂载出来：

# 同时挂载配置文件和数据，并启动设置密码启动
root@ubuntu:~# docker run -d -p 3310:3306 -v /home/mysql/conf:/etc/mysqlconf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 mysql:latest 
3b46a38d9d1bf45f20c68c87c8aee839bf0b3fe9c1a35633fcaefec520d34c7a
root@ubuntu:~# 

具名挂载和匿名挂载：（一般具名挂载，更容易管理）

#匿名挂载 -v 后不写主机路径 只写挂载路径，让它自行挂载。没有指定目录情况下查看挂载信息
docker volume ls # 查看卷名
docker volume inspect 挂载卷名

数据卷容器：实现容器间的通信(是双向拷贝的概念)
数据卷容器的挂载的生命周期，直到没有容器使用为止。

# 保证docker01是启动的   --volume-from
docker run -it --name docker02 --volume-from docker01 centos

DockerFile(及其重要)：

DockerFile就是用来构建docker的镜像文件的。 – 本质就是：命令脚本

通过这个脚本生成镜像，镜像是一层一层的，因此脚本也是一条条的。

先看看用命令脚本实现挂载：

#/bin/bash
from centos

volume ["volume01","volume02"]

cmd echo "-------end-------------"
cmd /bin/bash
~              

root@ubuntu:/home/test# vim dockfile01 
root@ubuntu:/home/test# docker build -f /home/test/dockfile01 -t zy/centos .
Sending build context to Docker daemon  2.048kB
Step 1/4 : from centos
 ---> 831691599b88
Step 2/4 : volume ["volume01","volume02"]
 ---> Running in f0f371a3500b
Removing intermediate container f0f371a3500b
 ---> 88a9caae6c9d
Step 3/4 : cmd echo "-------end-------------"
 ---> Running in a9e28a6ead27
Removing intermediate container a9e28a6ead27
 ---> e08e3bda7561
Step 4/4 : cmd /bin/bash
 ---> Running in 4826b7681519
Removing intermediate container 4826b7681519
 ---> a137e74bee75
Successfully built a137e74bee75
Successfully tagged zy/centos:latest
root@ubuntu:/home/test# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
zy/centos           latest              a137e74bee75        58 seconds ago      215MB
tomcat02            v1.0                b8fa9b7c4bd5        2 hours ago         652MB
tomcat              9.0                 9a9ad4f631f8        7 days ago          647MB
mysql               latest              e3fcc9e1cc04        13 days ago         544MB
nginx               latest              8cf1bfb43ff5        2 weeks ago         132MB
centos              latest              831691599b88        7 weeks ago         215MB
hello-world         latest              bf756fb1ae65        7 months ago        13.3kB

dockerfile构建步骤：

1. 编写一个dockfile文件
2. docker build 构建称为一个镜像
3. docker run 运行镜像
4. docker push 发布镜像（到dockerhub、阿里云仓库等）。

先看官方是如何发布一个镜像的：
mysql举例子


上面这个就是dockers架构图。docker现在成为了企业交付的标准，必须要掌握。

dockerFile的指令：

FROM # 基础镜像、一切从这里开始
MAINTAINER # 镜像是谁写的 姓名+邮箱
RUM # 镜像构建的时候需要的运行的命令
ADD # 步骤，tomcat镜像，这个tomcat的压缩包！添加内容
WORKDIR # 镜像的工作目录
VOLUME # 挂载的目录
EXPOSE # 保留端口配置
RUN # 运行命令
CMD 指定这个容器启动时候要运行的命令，只有最后一个生效。
ONBUILD # 当构建一个被继承的DockerFile 这个时候就会运行ONBUILD的指令，触发指令
COPY # 复制文件进容器中

形象网图：

查看官网：centos的dockerFile

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="20200611"

CMD ["/bin/bash"]

模仿它构建一个自己centos: （因为centos默认镜像是啥也没有）我么来配置一个我常用的基础工具的centos

root@ubuntu:/home/dockerfile# vim dockerFile-centos
root@ubuntu:/home/dockerfile# cat dockerFile-centos 
FROM centos
MAINTAINER zhouyi<zy96249454@163.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH

RUN yum -f install vim
RUN yum -f install net-tools

CMD echo $MYPATH
CMD echo "--------------------------"

CMD /bin/bash

通过上面dockerfile构建自己的镜像：并查看

root@ubuntu:/home/dockerfile# docker build -f dockerFile-centos -t base-centos:1.0 .
root@ubuntu:/home/dockerfile# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED              SIZE
base-centos         1.0                 591929e29652        About a minute ago   295MB
tomcat02            v1.0                b8fa9b7c4bd5        26 hours ago         652MB
tomcat              9.0                 9a9ad4f631f8        8 days ago           647MB
mysql               latest              e3fcc9e1cc04        2 weeks ago          544MB
nginx               latest              8cf1bfb43ff5        2 weeks ago          132MB
centos              latest              831691599b88        7 weeks ago          215MB
hello-world         latest              bf756fb1ae65        7 months ago         13.3kB

再来制作一个比较完整的tomcat，官网查看
利用rz命令上传：需要的jar包。

root@ubuntu:/opt# rz

root@ubuntu:/opt# rz

root@ubuntu:/opt# ls
apache-tomcat-9.0.37.tar.gz  containerd  jdk-8u261-linux-x64.tar.gz

# 移动到一起
root@ubuntu:/opt/tomcat-image# ls
apache-tomcat-9.0.37.tar.gz  jdk-8u261-linux-x64.tar.gz
root@ubuntu:/opt/tomcat-image# pwd
/opt/tomcat-image
# 默认官网推荐名字，可以不需要-f参数指定
root@ubuntu:/opt/tomcat-image# touch Dockerfile

1. 编写一个dockfile文件：
linux文件上传的方式：
FTP ： FTP是文件服务器，可实现文件的上传下载，存储等功能。
scp： scp能够将不同主机的文件进行相互传输，使用简单方便。
rz ： 用于linux与windows之间的文件上传 yum install lrzsz -y 或者apt-get install lrzsz
sz ： 用于linux与windows之间的文件下载
rsync ： rsync是文件同步工具，结合inotify可以实现文件的同步，备份功能。

ADD 命令会自动解压

root@ubuntu:/opt/tomcat-image# vim Dockerfile 
root@ubuntu:/opt/tomcat-image# cat Dockerfile 
FROM centos
MAINTAINER zhouyi<zy96249454@163.com>

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

# add 自动解压到指定目录
ADD apache-tomcat-9.0.37.tar.gz /usr/local
ADD jdk-8u261-linux-x64.tar.gz /usr/local

RUN yum -y install vim

# 工作目录设置
ENV MYPATH /usr/local
WORKDIR $MYPATH

# 环境变量设置
ENV JAVA_HOME /usr/local/jdk1.8.0_261
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.37
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.37
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

#端口暴露
EXPOSE 8080

# 启动命令，并打印日志
CMD /usr/local/apache-tomcat-9.0.37/bin/startup.sh && tail -f /usr/local/apache-tomcat-9.0.37/bin/logs/catalina.out

2. docker build 构建称为一个镜像: （可以看到就是按照命令层级执行）

root@ubuntu:/opt/tomcat-image# docker build -t mytomcat .
Sending build context to Docker daemon  154.3MB
Step 1/15 : FROM centos
 ---> 831691599b88
Step 2/15 : MAINTAINER zhouyi<zy96249454@163.com>
 ---> Using cache
 ---> 98951260b425
Step 3/15 : COPY readme.txt /usr/local/readme.txt
 ---> 8e3f73015285
Step 4/15 : ADD apache-tomcat-9.0.37.tar.gz /usr/local
 ---> 247d53abadfe
Step 5/15 : ADD jdk-8u261-linux-x64.tar.gz /usr/local
 ---> 9f289ca88690
Step 6/15 : RUN yum -y install vim
 ---> Running in 255f1bb66e88
CentOS-8 - AppStream                            2.1 MB/s | 5.8 MB     00:02    
CentOS-8 - Base                                 1.5 MB/s | 2.2 MB     00:01    
CentOS-8 - Extras                                11 kB/s | 7.0 kB     00:00    
Dependencies resolved.
================================================================================
 Package             Arch        Version                   Repository      Size
================================================================================
Installing:
 vim-enhanced        x86_64      2:8.0.1763-13.el8         AppStream      1.4 M
Installing dependencies:
 gpm-libs            x86_64      1.20.7-15.el8             AppStream       39 k
 vim-common          x86_64      2:8.0.1763-13.el8         AppStream      6.3 M
 vim-filesystem      noarch      2:8.0.1763-13.el8         AppStream       48 k
 which               x86_64      2.21-12.el8               BaseOS          49 k

Transaction Summary
================================================================================
Install  5 Packages

Total download size: 7.8 M
Installed size: 31 M
Downloading Packages:
(1/5): gpm-libs-1.20.7-15.el8.x86_64.rpm        214 kB/s |  39 kB     00:00    
(2/5): vim-filesystem-8.0.1763-13.el8.noarch.rp 828 kB/s |  48 kB     00:00    
(3/5): which-2.21-12.el8.x86_64.rpm             145 kB/s |  49 kB     00:00    
(4/5): vim-enhanced-8.0.1763-13.el8.x86_64.rpm  1.2 MB/s | 1.4 MB     00:01    
(5/5): vim-common-8.0.1763-13.el8.x86_64.rpm    3.0 MB/s | 6.3 MB     00:02    
--------------------------------------------------------------------------------
Total                                           2.5 MB/s | 7.8 MB     00:03     
warning: /var/cache/dnf/AppStream-02e86d1c976ab532/packages/gpm-libs-1.20.7-15.el8.x86_64.rpm: Header V3 RSA/SHA256 Signature, key ID 8483c65d: NOKEY
CentOS-8 - AppStream                            1.3 MB/s | 1.6 kB     00:00    
Importing GPG key 0x8483C65D:
 Userid     : "CentOS (CentOS Official Signing Key) <security@centos.org>"
 Fingerprint: 99DB 70FA E1D7 CE22 7FB6 4882 05B5 55B3 8483 C65D
 From       : /etc/pki/rpm-gpg/RPM-GPG-KEY-centosofficial
Key imported successfully
Running transaction check
Transaction check succeeded.
Running transaction test
Transaction test succeeded.
Running transaction
  Preparing        :                                                        1/1 
  Installing       : which-2.21-12.el8.x86_64                               1/5 
  Installing       : vim-filesystem-2:8.0.1763-13.el8.noarch                2/5 
  Installing       : vim-common-2:8.0.1763-13.el8.x86_64                    3/5 
  Installing       : gpm-libs-1.20.7-15.el8.x86_64                          4/5 
  Running scriptlet: gpm-libs-1.20.7-15.el8.x86_64                          4/5 
  Installing       : vim-enhanced-2:8.0.1763-13.el8.x86_64                  5/5 
  Running scriptlet: vim-enhanced-2:8.0.1763-13.el8.x86_64                  5/5 
  Running scriptlet: vim-common-2:8.0.1763-13.el8.x86_64                    5/5 
  Verifying        : gpm-libs-1.20.7-15.el8.x86_64                          1/5 
  Verifying        : vim-common-2:8.0.1763-13.el8.x86_64                    2/5 
  Verifying        : vim-enhanced-2:8.0.1763-13.el8.x86_64                  3/5 
  Verifying        : vim-filesystem-2:8.0.1763-13.el8.noarch                4/5 
  Verifying        : which-2.21-12.el8.x86_64                               5/5 

Installed:
  gpm-libs-1.20.7-15.el8.x86_64         vim-common-2:8.0.1763-13.el8.x86_64    
  vim-enhanced-2:8.0.1763-13.el8.x86_64 vim-filesystem-2:8.0.1763-13.el8.noarch
  which-2.21-12.el8.x86_64             

Complete!
Removing intermediate container 255f1bb66e88
 ---> 34a42e3cf6c6
Step 7/15 : ENV MYPATH /usr/local
 ---> Running in 020ea7944f71
Removing intermediate container 020ea7944f71
 ---> 586ce9d65226
Step 8/15 : WORKDIR $MYPATH
 ---> Running in b5634202ce11
Removing intermediate container b5634202ce11
 ---> d72a86a45edf
Step 9/15 : ENV JAVA_HOME /usr/local/jdk1.8.0_261
 ---> Running in 6477df9deef8
Removing intermediate container 6477df9deef8
 ---> 5e843bd4984f
Step 10/15 : ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
 ---> Running in 20032c82bfbb
Removing intermediate container 20032c82bfbb
 ---> a5eb075de2eb
Step 11/15 : ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.37
 ---> Running in 0df52b86e3ad
Removing intermediate container 0df52b86e3ad
 ---> d705243abe30
Step 12/15 : ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.37
 ---> Running in 627672e0c0b4
Removing intermediate container 627672e0c0b4
 ---> 3be723dfb5dd
Step 13/15 : ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
 ---> Running in 5fc19349be83
Removing intermediate container 5fc19349be83
 ---> 8142a799dc82
Step 14/15 : EXPOSE 8080
 ---> Running in 2ca0d87dd6c5
Removing intermediate container 2ca0d87dd6c5
 ---> 8dd322bde750
Step 15/15 : CMD /usr/local/apache-tomcat-9.0.37/bin/startup.sh && tail -f /usr/local/apache-tomcat-9.0.37/bin/logs/catalina.out
 ---> Running in 76527a171100
Removing intermediate container 76527a171100
 ---> f9c2a5b3032d
Successfully built f9c2a5b3032d
Successfully tagged mytomcat:latest
root@ubuntu:/opt/tomcat-image# 

查看：

root@ubuntu:/opt/tomcat-image# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED              SIZE
mytomcat            latest              f9c2a5b3032d        About a minute ago   641MB

3. 本地docker run 运行镜像测试:
这里启动做挂载，以后项目部署，只需要改/home/zhouyi/build/tomcat/test下的文件即可。
并做了日志同步挂载给/home/zhouyi/build/tomcat/tomcatlogs。

root@ubuntu:/opt/tomcat-image# docker run -d -p 9090:8080 --name zhouyi-tomcat -v /home/zhouyi/build/tomcat/test:/usr/local/apache-tomcat-9.0.37/webapps/test -v /home/zhouyi/build/tomcat/tomcatlogs:/usr/local/apache-tomcat-9.0.37/logs mytomcat
fe44c689bc84b34e231c478e022475fb20efa85de585893fe3876d31f4e2e099

如果你发现启动就退出，docker ps不可见，使用docker ps -a 查看所有容器，exit(1)原因可能如下:

• 也可能是机制问题，让它进入死循环。
• 原因内存不够。 df -h查看。
• docker容器的主线程（dockfile中CMD执行的命令）结束，容器会退出。

启动如下：得以成功。

docker run -d -p 9090:8080 --name mmytomcat -v /home/zhouyi/build/tomcat/test/:/usr/local/apache-tomcat-9.0.37/webapps/test -v /home/zhouyi/build/tomcat/tomcatlogs/:/usr/local/apache-tomcat-9.0.37/logs mytomcat /bin/sh -c "while true; do echo hello world; sleep 1; done"

进入并查看目录：可以看懂我们所安装的tomcat和jdk,readme.txt

root@ubuntu:/opt/tomcat-image# docker exec -it 49bde7285aa5 /bin/bash
[root@49bde7285aa5 local]# ll
bash: ll: command not found
[root@49bde7285aa5 local]# ls -l
total 52
drwxr-xr-x 1 root  root  4096 Aug  9 01:56 apache-tomcat-9.0.37
drwxr-xr-x 2 root  root  4096 May 11  2019 bin
drwxr-xr-x 2 root  root  4096 May 11  2019 etc
drwxr-xr-x 2 root  root  4096 May 11  2019 games
drwxr-xr-x 2 root  root  4096 May 11  2019 include
drwxr-xr-x 8 10143 10143 4096 Jun 18 06:59 jdk1.8.0_261
drwxr-xr-x 2 root  root  4096 May 11  2019 lib
drwxr-xr-x 2 root  root  4096 May 11  2019 lib64
drwxr-xr-x 2 root  root  4096 May 11  2019 libexec
-rw-r--r-- 1 root  root     0 Aug  8 12:07 readme.txt
drwxr-xr-x 2 root  root  4096 May 11  2019 sbin
drwxr-xr-x 5 root  root  4096 Jun 11 02:35 share
drwxr-xr-x 2 root  root  4096 May 11  2019 src

访问报错：实在解决不了。我curl百度是ok的，启动其他容器也是ok的。就是这个容器不行。不知道哪里错了。后面我们只说流程。

root@ubuntu:/home/zhouyi/build/tomcat/test# curl localhost:9090
curl: (56) Recv failure: Connection reset by peer

如果可以访问：

root@ubuntu:/home/zhouyi/build/tomcat/test# mkdir WEB-INF
root@ubuntu:/home/zhouyi/build/tomcat/test# cd WEB-INF/
root@ubuntu:/home/zhouyi/build/tomcat/test/WEB-INF/# vim web.xml
root@ubuntu:/home/zhouyi/build/tomcat/test# vim index.html

如下web.xml：

  <?xml version="1.0" encoding="UTF-8"?>
  <web-app xmlns="http://java.sun.com/xml/ns/javaee"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
                               http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
           version="2.5">

  </web-app>

index.html:

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>test-tomcat</title>
</head>
<body>
    <h1>我的第一个标题</h1>
    <p>我的第一个段落。</p>
</body>
</html>

项目部署完成，可以直接访问。

4. docker push 发布镜像（到dockerhub、阿里云仓库等）。
首先dockerhub注册自己的账号。

# 登陆
root@ubuntu:/home# docker log
login   logout  logs
# 登陆方法
root@ubuntu:/home# 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
# 登陆
root@ubuntu:/home# docker login -u username
Password:

# push上去
root@ubuntu:/home/zhouyi# docker push --help 

Usage:	docker push [OPTIONS] NAME[:TAG]
# 直接push  强烈建议详细带上tag
root@ubuntu:/home/zhouyi# docker push mytomcat

如果要放在阿里云上，查看文档照做即可。

Docker的网络：
清空镜像：

docker rmi -f $(docker images -aq)

三个网络：docker是如何访问容器的网络的。
发现容器启动时会得到一个eth0@if72的ip地址，是由docker分配的

root@ubuntu:/home/zhouyi# docker exec -it mytomcat 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
71: eth0@if72: <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

尝试ping: ping上面eth0@if72的ip地址.那这样就能ping通容器内部。

root@ubuntu:/home/zhouyi# 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.766 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.046 ms
64 bytes from 172.17.0.2: icmp_seq=3 ttl=64 time=0.072 ms
64 bytes from 172.17.0.2: icmp_seq=4 ttl=64 time=0.063 ms
64 bytes from 172.17.0.2: icmp_seq=5 ttl=64 time=0.084 ms
64 bytes from 172.17.0.2: icmp_seq=6 ttl=64 time=0.083 ms
64 bytes from 172.17.0.2: icmp_seq=7 ttl=64 time=0.086 ms

查看发现，是一对一对增加的，使用的evth-pair技术，一端连接协议，一端彼此相连。

因此容器也可以ping通另一个容器。

容器之间互联：

docker run -d -P --name tomcat02  --link ping tomcat01

这样能通过02 ping 01 反之不行。这就体现了–link不能支持相互连接。
官方也不推荐：
一般使用自定义网络：

root@ubuntu:~# docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
12a6e9b23cb7        bridge              bridge              local
6c14996eff23        host                host                local
dcce898c2df5        none                null                local
c7ad3e83ad0b        somenetwork         bridge              local

docker网络模式：桥接bridge、不配置none、主机host、容器网络连通container

自定义网络：
默认是桥接启动。

docker -d -P --name tomcat01 --net bridge tomcat

自定义命令查看：

root@ubuntu:~# docker network --help

Usage:	docker network COMMAND

Manage networks

Commands:
  connect     Connect a container to a network
  create      Create a network
  disconnect  Disconnect a container from a network
  inspect     Display detailed information on one or more networks
  ls          List networks
  prune       Remove all unused networks
  rm          Remove one or more networks

创建自定义网络：

# --driver 指定网路方式
# --subnet 指定子网 16最多连接三个 
# --gateway 指定网关  命名为mynet
root@ubuntu:~# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
51c1d940c3b5ed0011d9600cc705c4594ec7e6b1909309750bb1c54abe001d06
root@ubuntu:~# docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
12a6e9b23cb7        bridge              bridge              local
6c14996eff23        host                host                local
51c1d940c3b5        mynet               bridge              local
dcce898c2df5        none                null                local
c7ad3e83ad0b        somenetwork         bridge              local
root@ubuntu:~# docker inspect mynet
[
    {
        "Name": "mynet",
        "Id": "51c1d940c3b5ed0011d9600cc705c4594ec7e6b1909309750bb1c54abe001d06",
        "Created": "2020-08-09T00:41:24.368150984-07: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": {}
    }
]

启动时，选择自定义的网络启动：

root@ubuntu:~# docker run -d -P --name tomcat-net-01 --net mynet tomcat
955a483bcbafd8d7d3c2e9afae41ef44dc120ccc10843b13a85c0cd11e652dba
root@ubuntu:~# docker run -d -P --name tomcat-net-02 --net mynet tomcat
9fc5626f9633aa607f30e08ed4492938b4a6bde98623df569edc1658d8a638c4

再使用docker inspect mynet查看：

测试的结果：相互可ping（可以用名字也可以用ip来ping）

root@ubuntu:~# docker exec -it tomcat-net-01 ping tomcat-net-02
PING tomcat-net-02 (192.168.0.3) 56(84) bytes of data.
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=1 ttl=64 time=0.306 ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.117 ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=3 ttl=64 time=0.226 ms
^C
--- tomcat-net-02 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 14ms
rtt min/avg/max/mdev = 0.117/0.216/0.306/0.078 ms
root@ubuntu:~# docker exec -it tomcat-net-02 ping tomcat-net-01
PING tomcat-net-01 (192.168.0.2) 56(84) bytes of data.
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=1 ttl=64 time=0.076 ms
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=2 ttl=64 time=0.118 ms
^C
--- tomcat-net-01 ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 11ms
rtt min/avg/max/mdev = 0.076/0.097/0.118/0.021 ms

自定义网络的好处：不同的集群使用不同的网络。
比如：redis的集群、mysql的集群各自使用自己的网络，保证集群的安全。
上面我们自定义的mynet和docker自定分配的者两个网络之间怎么联通？

网络连通：

命令：

root@ubuntu:~# 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

连通并查看结果：就是单纯暴力的加了一条。这样是指定打通02 和mynet依依旧不通。

root@ubuntu:~# docker network connect mynet tomcat01 
root@ubuntu:~# docker inspect myne

。到此基本结束完成。

举例子：部署redis集群 = 分片 + 高可用 + 负载均衡。
删掉我们原来配置的网络，并添加redis的

root@ubuntu:~# docker network rm c7ad3e83ad0b 51c1d940c3b5
c7ad3e83ad0b
51c1d940c3b5
root@ubuntu:~# docker network create redis  --subnet 172.38.0.0/16

编写脚本创建6个redis：

# 脚本创建6个redis
for port in $(seq 1 6);\
do \
mkdir -p /mydata/redis/node-${port}/conf
touch /mydata/redis/node-${port}/conf/redis.conf
cat <<EOF> /mydata/redis/node-${port}/conf/redis.conf
port 6379
bind 0.0.0.0
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 172.38.0.1${port}
cluster-announce-port 6379
cluster-announce--bus-port 16379
appendonly yes
EOF
done

查看结果：

root@ubuntu:/mydata/redis# ls
node-1  node-2  node-3  node-4  node-5  node-6

脚本写法：
1、先测试一个能否启动：

root@ubuntu:/etc# docker run -p 6371:6379 -p 16371:16379 --name redis-1 -v /mydata/redis/node-1/data:/data -v /mydata/redis/node-1/conf/redis.conf:/etc/redis/redis.conf -d --net redis --ip 172.38.0.11 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf;
49234b9623f818cea03fb28c036fdf6b7904e26c2dc3eb61fc3c617a48bce735

脚本化：

for port in $(seq 1 6); \
do \ 
docker run -d -p 637${port}:6379 -p 1637${port}:16379 --name redis-${port} \
-v /mydata/redis/node-${port}/data:/data \
-v /mydata/redis/node-${port}/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.1${port} redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf; \
done

集群创建：

redis-cli --cluster create 172.38.0.11:6379 172.38.0.12:6379 172.38.0.13:6379 \
172.38.0.14:6379 172.38.0.15:6379 172.38.0.16:6379 --cluster-replicas 1

到此配置完成。

举例二，将springboot项目打包发布：
首先新建一个项目，保证可访问，jar运行可访问：

打包：

通过jar启动测试： 成功启动。

G:\activiti7\docker-demo\target>java -jar demo-0.0.1-SNAPSHOT.jar

在idea中编写Dockfile（插件,还有提示很好用的）
这个插件可以直接连接存储镜像的仓库比如阿里云、dockerhub

上传后直接构建镜像：并拿改镜像运行即可。以后测试也直接pull这个镜像拿去运行即可。

root@ubuntu:/home/idea-project# ll
total 16140
drwxr-xr-x 2 root root     4096 Aug  9 03:47 ./
drwxr-xr-x 6 root root     4096 Aug  9 03:44 ../
-rw-r--r-- 1 root root 16514103 Aug  9 02:55 demo-0.0.1-SNAPSHOT.jar
-rw-r--r-- 1 root root      114 Aug  9 03:43 Dockerfile
root@ubuntu:/home/idea-project# docker build -t springboot-demo-test .