Docker最新教程 （视频地址https://www.bilibili.com/video/BV1og4y1q7M4）

Docker概述

Docker为什么出现？

---

一款产品：开发–上线 两套环境！应用环境，应用配置！
开发—运维。问题：我在我电脑上可以运行！版本更新，导致服务不可用！对于运维来说，考验十分大？
环境配置十分麻烦，每个机器都要部署环境（集群Redis、ES、Hadoop…）!费时费力。
发布一个项目（jar+（Redis Mysql jdk ES）），项目能不能带上环境安装打包！
之前在服务器配置一个应用环境 Redis Mysql jdk ES Hadoop，配置超级麻烦，不能够跨平台。
传统：开发jar，运维来做！
现在：开发打包部署上线，一套流程做完！

java —apk–发布（应用商店）—张三使用apk–安装即可用！
Java—jar（环境）—打包项目带上环境（镜像）—（Docker仓库：商店）----下载发布的镜像–直接运行即可！

Docker给以上问题，提出了解决方案！

Docker的思想来自于集装箱！
JRE–多个应用（端口冲突）—原来都是交叉的
隔离：Docker核心思想！打包装箱！每个箱子是互相隔离的
Docker通过隔离机制，可以将服务器利用到极致

本质：所有技术都是因为出现了一些问题，需要去解决，才去学习

Docker的历史

---

2010年，几个搞IT的年轻人，就在美国成立了一家公司dotCloud
做一些pass的云计算服务！LXC有关的容器技术！
他们将自己的技术（容器化技术）命名就是Docker！
Docker刚刚诞生的时候，没有引起行业的注意！dotCloud，就活不下去！
2013年，Docker开源！
越来越多的人发现了docker的优点！火了，Docker每个月都会更新一个版本！
2014年4月9日，Docker1.0发布！
Docker为什么这么火？十分的轻巧！
在容器技术出现之前，我们都使用虚拟机技术！
虚拟机：在windows中装一个Vmware，通过这个软件我们可以虚拟出来一台或多台电脑！笨重！
虚拟机也属于虚拟化技术，Docker容器技术，也是一种虚拟化技术！

vm，linux centos原生镜像（一个电脑） 隔离，需要开启多个虚拟机！几个G 几分钟
docker，隔离。镜像（最核心的环境 4m+jdk+mysql）十分的小巧，运行镜像就可以了！小巧！ 几个M KB 秒级启动

到现在，所有开发人员都必须要学会Docker！

聊聊Docker

Docker是基于go语言开发的！开源项目

官网！https://www.docker.com/
文档！https://docs.docker.com/ 超级详细
仓库地址https://hub.docker.com/

Docker能干嘛！

---

之前的虚拟机技术

虚拟机技术缺点：
1、资源占用十分多
2、冗余步骤多
3、启动很慢！

容器化技术

容器化技术不是模拟的一个完整的操作系统

比较Docker和虚拟机技术的不同：

• 传统虚拟机，虚拟出一条硬件，运行一个完整的操作系统，然后在这个系统上安装和运行软件
• 容器内的应用是直接运行在宿主机的内容，容器是没有自己的内核的，也没有虚拟我们的硬件，所以就轻便了
• 每个容器间互相隔离，每个容器内都有一个属于自己的文件系统，互不影响

DevOps(开发、运维)

更快速的交付和部署
传统：一堆帮助文档，安装程序
Docker：打包镜像发布测试，一键运行
更便捷的升级和扩缩容
使用了Docker之后，我们部署应用就和搭积木一样
项目打包为一个镜像，扩展 服务器A！服务器B
更简单的系统运维
在容器化之后，我们的开发，测试环境都是高度一致的
更高效的计算资源利用
1核2g的服务器！Docker是内核级别的虚拟化，可以在一个物理机上运行很多的容器实例！容器的性能可以被压榨到极致

Docker安装

Docker的基本组成

---

镜像（image）：

docker镜像就好比是一个模版，可以通过这个模版来创建容器服务，tomcat镜像===》 run===》tomcat01容器（提供服务器），通过这个镜像可以创建多个容器（最终服务运行或者项目运行就是在容器中的）

容器（container）：

Docker利用容器技术，独立运行一个或者一个组应用，通过镜像来创建的。
启动，停止，删除，基本命令！
目前就可以把这个容器理解为一个简易的linux系统

仓库（repository）：

仓库就是存放镜像的地方！
仓库分为公有仓库和私有仓库！
Docker Hub（默认是国外的）
阿里云。。。都有容器服务器（配置镜像加速！）

安装docker

环境准备
1、需要会一点linux的基础
2、CentOS7
3、使用Xshell连接远程服务器进行操作！

环境查看

# 系统内核
[root@hadoop105 /]# uname -r
5.1.0-1.el7.elrepo.x86_64
[root@hadoop105 /]# 

# 系统版本
[root@hadoop105 /]# 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"

安装

帮助文档：

# 1、卸载旧的版本
yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
# 2、需要的安装包
yum install -y yum-utils
# 3、设置镜像的仓库
yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo# 默认国外的

yum-config-manager \
    --add-repo \
    http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo# 推荐使用阿里云的

#更新yum软件包索引
yum makecache fast

# 4、安装docker相关的 docker-ce 社区 ee 企业版
yum install docker-ce docker-ce-cli containerd.io

# 5、启动docker
systemctl start docker

# 6、使用docker version 是否安装成功

# 7、hello-world
docker run hello-world

# 8、查看一下这个hello-world镜像
[root@hadoop105 ~]# docker images
REPOSITORY                   TAG                 IMAGE ID            CREATED             SIZE
daocloud.io/library/nginx    latest              2622e6cca7eb        4 months ago        132MB
hello-world                  latest              bf756fb1ae65        9 months ago        13.3kB
daocloud.io/library/tomcat   8.5.15-jre8         b8dfe9ade316        3 years ago         334MB
daocloud.io/library/mysql    5.7.4               aa5364eb3d85        6 years ago         252MB

了解：卸载docker

# 1、卸载依赖
yum remove docker-ce docker-ce-cli containerd.io
# 2、删除资源
rm -rf /var/lib/docker
# /var/lib/docker docker的默认工作路径

阿里云镜像加速

1、登陆阿里云找到容器服务

2、找到镜像加速地址

3、配置使用

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
     
  "registry-mirrors": ["https://xa2xb78w.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

回顾HelloWorld

---

底层原理

---

Docker是怎么工作的？
Docker 是一个Client -Server结构的系统，Docker的守护进程运行在主机上。通过Socket从客户端访问。
DockerServer接收到Docker-Client 的指令，就会执行这个命令。

Docker为什么比VM快？

1、Docker有着比虚拟机更少的抽象层
2、docker利用的是宿主机的内核，vm需要的是Guest OS

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

之后学完所有命令，再回过头来看这段理论就会很清晰

Docker的常用命令

---

帮助命令

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

帮助文档的地址：https://docs.docker.com/reference/#command-line-interfaces-clis

镜像命令

---

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

[root@hadoop105 /]#  docker images
REPOSITORY                   TAG                 IMAGE ID            CREATED             SIZE

hello-world                  latest              bf756fb1ae65        9 months ago        13.3kB

# 解释
REPOSITORY    镜像的仓库源
TAG           镜像的标签
IMAGE ID      镜像的id
CREATED       镜像的创建时间   
SIZE          镜像的大小
# 可选项
 -a, --all         # 列出所有镜像
 -q, --quiet       # 只显示镜像的id

docker search 搜索镜像

[root@hadoop105 /]# docker search mysql
NAME                              DESCRIPTION                                     STARS               OFFICIAL            AUTOMATED
mysql                             MySQL is a widely used, open-source relation…   10103               [OK]                
mariadb                           MariaDB is a community-developed fork of MyS…   3708                [OK]                

# 可选项，通过搜索过滤
--filter=STARS=3000 # 搜索出来的镜像就是STARS大于3000
                                
[root@hadoop105 /]# docker search mysql --filter=STARS=3000
NAME                DESCRIPTION                                     STARS               OFFICIAL            AUTOMATED
mysql               MySQL is a widely used, open-source relation…   10103               [OK]                
mariadb             MariaDB is a community-developed fork of MyS…   3708                [OK]                

[root@hadoop105 /]# docker search mysql --filter=STARS=5000
NAME                DESCRIPTION                                     STARS               OFFICIAL            AUTOMATED
mysql               MySQL is a widely used, open-source relation…   10103               [OK]      

docker pull 下载镜像

# 下载镜像 docker pull 镜像名[:tag]
[root@hadoop105 /]# docker pull mysql 
Using default tag: latest #如果不写tag，默认就是latest
latest: Pulling from library/mysql
bb79b6b2107f: Pull complete  # 分层下载，docker image的核心 联合文件下载
49e22f6fb9f7: Pull complete 
842b1255668c: Pull complete 
9f48d1f43000: Pull complete 
c693f0615bce: Pull complete 
8a621b9dbed2: Pull complete 
0807d32aef13: Pull complete 
a56aca0feb17: Pull complete 
de9d45fd0f07: Pull complete 
1d68a49161cc: Pull complete 
d16d318b774e: Pull complete 
49e112c55976: Pull complete 
Digest: sha256:8c17271df53ee3b843d6e16d46cff13f22c9c04d6982eb15a9a47bd5c9ac7e2d
Status: Downloaded newer image for mysql:latest #签名
docker.io/library/mysql:latest #真实地址

# 等价
docker pull mysql
docker pull docker.io/library/mysql:latest 
#指定版本下载
[root@hadoop105 /]# docker pull mysql:5.7
5.7: Pulling from library/mysql
bb79b6b2107f: Already exists 
49e22f6fb9f7: Already exists 
842b1255668c: Already exists 
9f48d1f43000: Already exists 
c693f0615bce: Already exists 
8a621b9dbed2: Already exists 
0807d32aef13: Already exists 
f15d42f48bd9: Pull complete 
098ceecc0c8d: Pull complete 
b6fead9737bc: Pull complete 
351d223d3d76: Pull complete 
Digest: sha256:4d2b34e99c14edb99cdd95ddad4d9aa7ea3f2c4405ff0c3509a29dc40bcb10ef
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7

docker rmi 删除镜像

[root@hadoop105 /]# docker rmi -f  容器id # 删除指定的容器    
[root@hadoop105 /]# docker rmi -f  容器id  容器id 容器id #删除多个容器    
[root@hadoop105 /]# docker rmi -f  $(docker images -aq) # 删除全部的容器    

容器命令

---

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

docker pull centos

新建容器并启动

docker run [可选参数] image

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

# 启动并进入容器
[root@hadoop105 /]# docker run -it centos /bin/bash
[root@9b861b70c610 /]# 


[root@9b861b70c610 /]# ls #查看容器的centos，基础版本，很多命令都是不完善的
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var

# 从容器中退回主机
[root@9b861b70c610 /]# exit
exit
[root@hadoop105 /]# ls
bin  boot  dev  etc  ftpfile  home  lib  lib64  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var

列出所有运行的容器

# docker ps 命令
    # 列出当前正在运行的容器
-a  # 列出当前正在运行的容器，带出历史运行的容器
-n=?# 显示最近创建的容器
-q  # 只显示容器的编号

[root@hadoop105 /]# docker ps
CONTAINER ID        IMAGE                                    COMMAND                  CREATED             STATUS                              PORTS                    NAMES
6e54f39a423b        daocloud.io/library/nginx:latest         "/docker-entrypoint.…"   3 months ago        Restarting (1) About a minute ago                            nginx
6d9a7cd4e9d0        daocloud.io/library/mysql:5.7.4          "/entrypoint.sh mysq…"   3 months ago        Up 6 hours                          0.0.0.0:3306->3306/tcp   mysql
40629088ade0        daocloud.io/library/tomcat:8.5.15-jre8   "catalina.sh run"        3 months ago        Up 6 hours                          0.0.0.0:8080->8080/tcp   tomcat
[root@hadoop105 /]# docker ps -a
CONTAINER ID        IMAGE                                    COMMAND                  CREATED             STATUS                        PORTS                    NAMES
9b861b70c610        centos                                   "/bin/bash"              4 minutes ago       Exited (0) 3 minutes ago                               hardcore_goldwasser
6b6a375b1228        hello-world                              "/hello"                 22 hours ago        Exited (0) 22 hours ago                                confident_elgamal
6e54f39a423b        daocloud.io/library/nginx:latest         "/docker-entrypoint.…"   3 months ago        Restarting (1) 1 second ago                            nginx
6d9a7cd4e9d0        daocloud.io/library/mysql:5.7.4          "/entrypoint.sh mysq…"   3 months ago        Up 6 hours                    0.0.0.0:3306->3306/tcp   mysql
40629088ade0        daocloud.io/library/tomcat:8.5.15-jre8   "catalina.sh run"        3 months ago        Up 6 hours                    0.0.0.0:8080->8080/tcp   tomcat

退出容器

exit # 直接容器停止并退出
Ctrl+P+Q # 容器不停止退出

删除容器

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

启动和停止容器的操作

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

常用的其他命令

后台启动容器

# 命令 docker run -d 镜像名
[root@hadoop105 ~]# docker run -d centos

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

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

查看日志

docker logs -f -t --tail 容器，没有日志

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

# [root@hadoop105 /]# docker ps
CONTAINER ID        IMAGE              
2108bee778a9        centos       

# 显示日志
-tf #显示日志
--tail number # 要显示日志的条数
[root@hadoop105 /]# docker logs  -tf --tail 10 2108bee778a9    

查容器中的进程信息 ps

#  命令 docker top 容器id
[root@hadoop105 /]# docker top 2108bee778a9   
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                12999               12981               0                   09:40               ?                   00:00:00            /bin/sh -c while true;do echo gn;sleep 1;done
root                23214               12999               0                   09:49               ?                   00:00:00            /usr/bin/coreutils --coreutils-prog-shebang=sleep /usr/bin/sleep 1

查看镜像元数据

# 命令  
docker inspect 容器id

#测试
[root@hadoop105 /]# docker inspect 2108bee778a9  
[
    {
     
        "Id": "2108bee778a923e00162edb5b2f9abd8efe4aac53994d6e61f04d8d89b2170c0",
        "Created": "2020-10-28T01:40:52.948969031Z",
        "Path": "/bin/sh",
        "Args": [
            "-c",
            "while true;do echo gn;sleep 1;done"
        ],
        "State": {
     
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 12999,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2020-10-28T01:40:55.221475585Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:0d120b6ccaa8c5e149176798b3501d4dd1885f961922497cd0abef155c869566",
        "ResolvConfPath": "/var/lib/docker/containers/2108bee778a923e00162edb5b2f9abd8efe4aac53994d6e61f04d8d89b2170c0/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/2108bee778a923e00162edb5b2f9abd8efe4aac53994d6e61f04d8d89b2170c0/hostname",
        "HostsPath": "/var/lib/docker/containers/2108bee778a923e00162edb5b2f9abd8efe4aac53994d6e61f04d8d89b2170c0/hosts",
        "LogPath": "/var/lib/docker/containers/2108bee778a923e00162edb5b2f9abd8efe4aac53994d6e61f04d8d89b2170c0/2108bee778a923e00162edb5b2f9abd8efe4aac53994d6e61f04d8d89b2170c0-json.log",
        "Name": "/relaxed_nightingale",
        "RestartCount": 0,
        "Driver": "devicemapper",
        "Platform": "linux",
        "MountLabel": "",
        "ProcessLabel": "",
        "AppArmorProfile": "",
        "ExecIDs": null,
        "HostConfig": {
     
            "Binds": null,
            "ContainerIDFile": "",
            "LogConfig": {
     
                "Type": "json-file",
                "Config": {
     }
            },
            "NetworkMode": "default",
            "PortBindings": {
     },
            "RestartPolicy": {
     
                "Name": "no",
                "MaximumRetryCount": 0
            },
            "AutoRemove": false,
            "VolumeDriver": "",
            "VolumesFrom": null,
            "CapAdd": null,
            "CapDrop": null,
            "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": {
     
                "DeviceId": "79",
                "DeviceName": "docker-8:3-257979-9b08f683794a2668200ad198f003c638684b505b2c5fea4efb6586d25bf8470f",
                "DeviceSize": "10737418240"
            },
            "Name": "devicemapper"
        },
        "Mounts": [],
        "Config": {
     
            "Hostname": "2108bee778a9",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
            ],
            "Cmd": [
                "/bin/sh",
                "-c",
                "while true;do echo gn;sleep 1;done"
            ],
            "Image": "centos",
            "Volumes": null,
            "WorkingDir": "",
            "Entrypoint": null,
            "OnBuild": null,
            "Labels": {
     
                "org.label-schema.build-date": "20200809",
                "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": "6672d2ae010aa6c1b89b8de069791f1c2f1043ae98da6a3b6416bfd3417ef610",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {
     },
            "SandboxKey": "/var/run/docker/netns/6672d2ae010a",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "7539ef455a8c80719e0ee7867198ac1dd5e777a7688c19021f592b9a4587cfd8",
            "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": "0a46512667a5251f4047e96dc6759ec0e76a2ff0c3a56603de63b56bddc8442c",
                    "EndpointID": "7539ef455a8c80719e0ee7867198ac1dd5e777a7688c19021f592b9a4587cfd8",
                    "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
                }
            }
        }
    }
]

进入当前正在运行的容器

# 通常容器都是使用后台方式运行的，需要进入容器，修改一些配置

# 命令
docker exec -it 容器id bashShell
# 测试
[root@hadoop105 /]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS               NAMES
2108bee778a9        centos              "/bin/sh -c 'while t…"   17 minutes ago      Up 17 minutes                           relaxed_nightingale
[root@hadoop105 /]# docker exec -it 2108bee778a9 /bin/bash
[root@2108bee778a9 /]# ls
bin  etc   lib    lost+found  mnt  proc  run   srv  tmp  var
dev  home  lib64  media       opt  root  sbin  sys  usr
[root@2108bee778a9 /]# ps -ef
UID         PID   PPID  C STIME TTY          TIME CMD
root          1      0  0 01:40 ?        00:00:00 /bin/sh -c while true;do echo gn;sleep 1
root       1118      0  0 01:59 pts/0    00:00:00 /bin/bash
root       1145      1  0 01:59 ?        00:00:00 /usr/bin/coreutils --coreutils-prog-sheb
root       1146   1118  0 01:59 pts/0    00:00:00 ps -ef

# 方式二
docker attach 容器id
# 测试
[root@hadoop105 /]# docker attach  2108bee778a
正在执行当前的代码

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

从容器内拷贝文件到主机

docker cp 容器id:容器内路径 目的主机路径

# 查看当前主机目录下
[[root@hadoop105 Downloads]# ls
gn.java
[[root@hadoop105 Downloads]# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
01536b4ed4d4         centos              "/bin/bash"         8 minutes ago       Up 8 minutes                            ecstatic_albattani

# 进入docker容器内部
[root@hadoop105 Downloads]# docker attach 01536b4ed4d4 
[root@01536b4ed4d4 /]# cd /home
[root@01536b4ed4d4 home]# ls

# 在容器内新建一个文件
[root@01536b4ed4d4 home]# touch test.java
[root@01536b4ed4d4 home]# exit
exit
[root@hadoop105 Downloads]# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
[root@hadoop105 Downloads]# docker ps -a
CONTAINER ID        IMAGE               COMMAND             CREATED              STATUS                        PORTS               NAMES
01536b4ed4d4        centos              "/bin/bash"         About a minute ago   Exited (0) 12 seconds ago  

# 将文件拷贝出来到主机上      
[root@hadoop105 Downloads]# docker cp 01536b4ed4d4:/home/test.java /Downloads
[root@hadoop105 Downloads]# ls
CentOS7-Base-163.repo test.java

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

小结

attach   #当前shel]下 attach连接指定运行镜像
build    #通过 Dockerfile定制镜像
commit   #提交当前容器为新的镜像
cp       #从容器中拷贝指定文件或者目录到宿主机中
create   #创建一个新的容器,同run,但不启动容器
diff     #查看 docker容器变化
events   #从 docker服务获取容器实时事件
exec     #在已存在的容器上运行命令
export   #导出容器的内容流作为一个tar归档文件[对应import]
history  #展示一个镜像形成历史
images   #列出系统当前镜像
import   #从tar包中的内容创建一个新的文件系统映像[对应 export]
info     #显示系统相关信息
inspect  #查看容器详细信息
kill     #ki11指定 docker容器
load     #从一个tar包中加载一个镜像[对应save]
login    #注册或者登陆一个 docker源服务器
logout   #从当前 Docker registry退出
logs     #输出当前容器日志信息
port     #査看映射端口对应的容器内部源端
pause    #暂停容器
ps       #列出容器列表
pull     #从 docker镜像源服务器拉取指定镜
push     #推送指定镜像或者库镜像至docker源服务器
restart  #重启运行的容器
rm       #移除一个或者多个容器

rmi      #除一个或多个镜像[无容器使用该镜像才可删除,否则需删除相关容器才可继续或-f强制删除]
run      #创建一个新的容并运行一个命令
save     #保存一个镜像为一个tar包[对应1oad]
search   #在 docker hub中搜索镜像
start    #启动容器
stop     #停止容器
tag      #给源中镜像打标签
top      #查看容器中运行的进程信息
unpause  #取消暂停容器
version  #查看 docker版本号
wait     #截取容器停止时的退出状态值

练习

安装Nginx

#1、搜索镜像 search 去docker搜索，可以看官方文档
#2、下载镜像 pull
#3、运行测试
[root@hadoop105 ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
# -d 后台运行
# --name 给容器命名
# -p 宿主机端口:容器内部端口
[root@hadoop105 ~]# docker run -d --name ng inxO1 -p 3344: 80 ngin
8d3b2b2d195bb8936b883c4ab4332ea4e976a17d5cc30c8a42d4076840a9677a
[root@hadoop105 ~]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                    NAMES
8d3b2b2d195b        nginx               "/docker-entrypoint.…"   4 hours ago         Up 4 hours          0.0.0.0:3344->80/tcp     nginx01
[root@hadoop105 ~]# curl localhost:3344

# 进入容器
[root@hadoop105 ~]# docker exec -it nginx01 /bin/bash
root@8d3b2b2d195b:/# whereis nginx
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx
root@8d3b2b2d195b:/# cd  /etc/nginx
root@8d3b2b2d195b:/etc/nginx# ls
conf.d          koi-utf  mime.types  nginx.conf   uwsgi_params
fastcgi_params  koi-win  modules     scgi_params  win-utf
root@8d3b2b2d195b:/etc/nginx# 

端口暴露的概念

思考问题:每次改动 nginx配置文件,都需要进入容器内部?十分的麻烦,要是可以在容器外部提供一个映射路径,达到在
容器修改文件名,容器内部就可以自动修改? -v 数据卷!

安装Tomcat

# 官方使用
docker run -it --rm tomcat:9.0

# 之前的启动都是后台，停止了容器之后，容器还是可以查到 docker run -it --rm 一般用来测试，用完就删除

#下载再启动
docker pull tomcat

# 启动运行
docker run -d -p 3355:8080 --name tomcat01 tomcat

# 测试访问没有问题

# 进入容器
[root@hadoop105 ~]# docker exec -it tomcat01/bin/bash
#发现问题:1、1inux命令少了,2没有webapps 阿里云镜象的原因。默认是最小的镜傲,所有不必要的都剔除掉
#保证最小可运行的环境

思考问题:以后要部署项目,如果每次都要进入容器是不是十分麻烦?要是可以在容器外部提供一个映射路径, webapps，
在外部放置项目,就自动同步到内部就好了！

部署es+kubana

# es 暴露的端口很多
# es 十分耗内存
# es 数据一般需要放置到安全目录！挂载
# --net somenetwork ？ 网络配置

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

# 启动了linux卡住了 docker stats 查看cpu状态

# es 是十分耗内存的 1.xG  1核2G

# 查看docker stats

# 测试es 是否成功
[root@hadoop105 ~]# curl localhost:9200
{
     
  "name" : "bdeb13af59bc",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "4cP061UvRc-neOtdzg2Cqg",
  "version" : {
     
    "number" : "7.6.2",
    "build_flavor" : "default",
    "build_type" : "docker",
    "build_hash" : "ef48eb35cf30adf4db14086e8aabd07ef6fb113f",
    "build_date" : "2020-03-26T06:34:37.794943Z",
    "build_snapshot" : false,
    "lucene_version" : "8.4.0",
    "minimum_wire_compatibility_version" : "6.8.0",
    "minimum_index_compatibility_version" : "6.0.0-beta1"
  },
  "tagline" : "You Know, for Search"
}
#成功，迅速关闭，增加内存限制

# 迅速关闭，增加内存限制,修改配置文件 -e 环境配置修改
docker run -d --name elasticsearch02 -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2

# 查看 docker stats

{
     
  "name" : "72234dd3b392",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "tC8U-8rmQN6w56suB2znvw",
  "version" : {
     
    "number" : "7.6.2",
    "build_flavor" : "default",
    "build_type" : "docker",
    "build_hash" : "ef48eb35cf30adf4db14086e8aabd07ef6fb113f",
    "build_date" : "2020-03-26T06:34:37.794943Z",
    "build_snapshot" : false,
    "lucene_version" : "8.4.0",
    "minimum_wire_compatibility_version" : "6.8.0",
    "minimum_index_compatibility_version" : "6.0.0-beta1"
  },
  "tagline" : "You Know, for Search"
}

使用kibana连接es？网络如何才能连接过去？

可视化

---

• portainer(先用这个)

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

• Rancher（CI/CD在再用）

什么是portainer ？

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

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

访问测试：外网：8088（linux知识-》阿里云开通外网）

选择本地：

进入之后的面板

Docker 镜像讲解

镜像是什么

---

镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软，它包含运行某个软件所需的所有内容，包括代码、运行时、库、环境变量和配置文件。
所有的应用,直接打包 docker镜像,就可以直接跑起来!

如何得到镜像：

• 从远程仓库下载
• 朋友拷贝给你
• 自己制作一个镜像 DockerFile

Docker镜像加载原理

UnionFS(联合文件系统)

我们下载的时候看到的一层层就是这个!

UnionFS(联合文件系统): Union文件系统( UnionFS)是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改
作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下（ unite several directories into a single virtual filesystem）。 Union文件系统是 Docker镜像的基础。镜像可以通过分层来进行继承，基于基础镜像(没有父镜像)，可以制作各种具体的应用镜像。

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

Docker镜像加载原理

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

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

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

平时安装的虚拟机的CentOS有好几个G，为什么Docker这里才200M?

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

虚拟机是分钟级别,容器是秒级。

分层理解

注意日志输出

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

查看镜像分层的方式可以通过 docker image inspect命令。

   "RootFS": {
     
            "Type": "layers",
            "Layers": [
                "sha256:d0fe97fa8b8cefdffcef1d62b65aba51a6c87b6679628a2b50fc6a7a579f764c",
                "sha256:832f21763c8e6b070314e619ebb9ba62f815580da6d0eaec8a1b080bd01575f7",
                "sha256:223b15010c47044b6bab9611c7a322e8da7660a8268949e18edde9c6e3ea3700",
                "sha256:6a9976a8f40851f45dc8c68a04b130e90522f46bb7e8403c6e7eb4331674f213",
                "sha256:c875a9fc3ec72b140e325e1a1b3b57d299b91811e8288a07c6b788b0d7cba185",
                "sha256:d9364cb75b1a364fbcb97b2f51332fc012ae0321e18c3fd3811f5e5a9f8a2d0e"
            ]
        },
        "Metadata": {
     
            "LastTagTime": "0001-01-01T00:00:00Z"
        }

理解：

所有的 Docker镜像都起始于一个基础镜像层，当进行修改或增加新的内容时，就会在当前镜像层之上，创建新的镜像层。

举一个简单的例子,假如基于 Ubuntu linux16.04创建一个新的镜像，这就是新镜像的第一层；如果在该镜像中添加 Python包，就会在基础镜像层之上创建第二个镜像层；如果继续添加—个安全补，就会创建第三个镜像层。

该镜像当前已经包含3个镜像层，如下图所示(这只是一个用于演示的很简单的例子)

在添加额外的镜像层的同，镜像始终保持是当前所有镜像的组合，理解这一点非常重要。下图中举了一个简单的例子，每个镜像层包含3个文，而镜像包含了来自两个镜像层的6个文件。

上图中的镜像层跟之前图中的略有区，主要目的是便于展示文件。
下图中展示了一个稍微复杂的三层镜像，在外部看来整个镜像只有6个文件，这是因为最上层中的文件7是文件5的一个更新版本。

这种情况下，上层镜像层中的文件覆盖了底层镜像层中的文件。这样就使得文件的更新版本作为一个新镜像层添加到镜像当中。

Docker通过存储引擎(新版本采用快照机制)的方式来实现镜像层堆栈，并保证多镜像层对外展示为统一的文件系统。

Linux上可用的存储引擎有AUFS、 Overlay2、 Device Mapper.、Btrfs以及ZFS。顾名思义，每种存储引擎都基于 Linux中对应的文件系统或者块设备技术，并且每种存储引擎都有其独有的性能特点。

Docker在 Windows上仅支持 windowsfilter一种存储引擎，该引擎基于NTFS文件系统之上实现了分层和CoW

下图展示了与系统显示相同的三层镜像。所有镜像层堆并合井,对外提供统一的视图。

特点

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

这一层就是我们通常说的容器层，容器之下的都叫镜像层!

commit 镜像

docker commit 提交容器成为一个新的副本

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

测试

# 1、启动一个默认的tomcat

# 2、发现这个默认的tomcat 是没有webapps应用 镜像的原因，官方默认镜像 webapps下面是没有文件的

# 3、自己拷贝进去了基本的文件

# 4、操作过的容器通过commit提交为一个镜像，以后就使用修改的镜像即可

容器数据卷

什么是容器数据卷

docker的理念

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

数据？如果将数据放在容器中，如果容器删除，数据就会丢失！需求：数据可以持久化

MySQL，容器删了，删库跑路！需求：Mysql数据可以存储在本地

容器之间可以有一个数据共享的技术！Docke容器中产生的数据，同步到本地！

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

总结：容器的持久化和同步操作！容器间也是可以数据共享的！

使用数据

方式一：直接通过命令来挂载 -v

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

# 测试
[root@hadoop105 home]# docker run -it -v /home/ceshi:/home centos /bin/bash

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

测试文件的同步

测试：

1、停止容器
2、宿主机上修改文件
3、启动容器
4、容器内的数据依旧是同步的

好处：只需要在本地修改即可，容器内自动同步

安装MySQL

MySQL的数据持久化问题

# 获取镜像
[root@hadoop105 home]# docker pull mysql:5.7

# 运行容器，需要做数据挂载! # 安装启动mysql 需要配置密码 注意
# 官方测试 ：docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

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

# 启动成功之后，在本地navicat工具测试连接
# navicat连接到服务的3310---3310和容器内的3306映射，连接成功

# 在本地测试创建一个数据库，查看映射路径是否ok

将容器删除

发现，挂载到本地的数据卷依旧没有丢失，这就实现了容器数据持久化功能！

具名和匿名挂载挂载

# 匿名挂载
-v 容器内路径
docker run -d -P --name nginx01 -v/etc/nginx nginx

# 查看所有卷的情况
[root@hadoop105 ~]# docker volume ls
local               87f6b325748971edc149dc40c34a1b35b90826e7f8016c893bb7ed79309314a0

# 这里发现，这种就是匿名挂载 在-v只写了容器内的路径，没有写容器外的路！

# 具名挂载
[root@hadoop105 ~]# docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx
20766d38884d9f4cf9fe088402be2d95206dd80f73c1586c6dc8cc369699480b

[root@hadoop105 ~]# docker volume ls
DRIVER              VOLUME NAME
local               juming-nginx

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

所有的docker容器内的卷，没有指定目录的情况下在/var/lib/docker/volumes/xxxx/_data
通过具名挂载可以方便的找到卷，大多数情况在使用具名挂载

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

扩展：

# 通过 -v 容器内路径:ro rw 改变读写权限
ro  readonly        #只读
rw readwrite       #读写

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

#  ro：说明这个路径只能通过宿主机操作，容器内部无法操作

初识 DockerFile

---

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

# 创建一个dockerfile文件，名字可以随机 建议 Dockerfile
# 文件中的内容 指令(大些)  参数
FROM centos

VOLUME ["volume01","volume02"]

CMD echo "-----end-----"
CMD /bin/bash

# 这里的每个命令，就是镜像的一层

# 启动自己写的容器

这个卷和外部一定有一个同步的目录！

查看卷挂载路径

测试刚才的文件是否同步
这种方式以前使用十分多，因为我们通常会构建自己的镜像！
假设构建镜像时没有挂载卷，要手动镜像挂载 -v 卷名：容器内路径

数据卷容器

---

两个mysql同步数据！

# 启动3个容器 通过自己写的镜像启动

# 删除docker01，docker02和docker03还是可以访问文件

多个mysql实现数据共享

 [root@hadoop105 home]# docker run -d -p 3310:3306 -v /etc/mysql/conf.d  -v /var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7
 [root@hadoop105 home]# docker run -d -p 3310:3306 -e MYSQL_ROOT_PASSWORD=123456 --name mysql02  --volumes-from mysql01 mysql:5.7
 # 可以实现两个容器的数据同步

结论：
容器之间配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止
但是一旦持久化到本地，这个时候，本地的数据是不会删除的

DockerFile

---

DockerFile介绍

dockerfile是用来构建docker镜像的文件！命令参数脚本！
构建步骤：
1、编写一个dockerfile文件
2、docker build构建成为一个镜像
3、docker run运行镜像
4、docker push发布镜像（DockerHub、阿里云镜像仓库）


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

DockerFile构建过程

---

基础知识：
1、每个保留关键字（指令)都必须是大写字母
2、执行从上到下顺序执行
3、# 表示注释
4、每一个指令都会创建提交一个新的镜像层，并提交！

dockerfile是面向开发的，以后要发布项目，做镜像，就需要编写dockerfile文件，这个文件十分简单
Docker镜像逐渐成为企业交付的标准
步骤：
DockerFile：构建文件，定义了一切步骤，源代码
DockerImages：通过DockerFile构建生成的镜像，最终发布和运行的产品
Docker容器：容器就是镜像运行起来提供服务器

DockerFile的指令

FROM              # 基础镜像，一切从这里开始
MAINTAINER  # 镜像是谁写的，姓名+邮箱
RUN                # 镜像构建的时候需要运行的命令
ADD                # 步骤：tomocat镜像，这个tomcat压缩包！添加内容
WORKDIR      # 镜像的工作目录
VOLUME        # 挂载的目录
EXPOST        # 保留端口配置
CMD              # 指定这个容器启动的时候要运行的命令 ，只有最后一个会生效，可被替代
ENTRYPOINT # 指定这个容器启动的时候要运行的命令，可以追加命令
ONBUILD     # 当构建一个被继承 Dockerfile 这个时候就会运行 ONBUILD 的指令。触发指令
COPY          # 类似ADD 将我们的文件拷贝到镜像中
ENV             # 构建的时候设置环境变量

测试

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

创建一个自己的centos

# 1、编写Dockerfile文件
[root@hadoop105 home]# cd dockerfile/
[root@hadoop105 dockerfile]# vim mydockerfile-centos
[root@hadoop105 dockerfile]# cat mydockerfile-centos 
FROM centos
MAINTAINER gn<[email protected]>

ENV MYPATH /usr/local
WORKDIR $MYPATH

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

EXPOSE 80

CMD echo $MYPATH
CMD echo "---end---"
CMD /bin/bash

# 2、通过文件构建镜像
# 命令 docker build -f  dockerfile文件路径 -t 镜像名:[tag]
Successfully built 9fde00d32767
Successfully tagged mycentos:0.1

# 3、测试运行

对比：之前原生的centos

增加之后的镜像

可以列出本地镜像的变更历史

CMD和ENTRYPOINT 区别

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

测试cmd

#  1、编写dockerfile文件
[root@hadoop105 dockerfile]# vim dockerfile-cmd-test 
FROM centos
CMD ["ls","-a"]

#  2、构建镜像（结尾必须加点）
[root@hadoop105 dockerfile]# docker build -f dockerfile-cmd-test -t cmdtest .

# 3、run运行 ls -a命令生效
[root@hadoop105 dockerfile]# docker run c92236f0921d

.
..
.dockerenv
bin
dev
etc
home
lib
lib64

# 4、追加一个命令 -l  ls -al 
[root@hadoop105 dockerfile]# docker run c92236f0921d -l
docker: Error response from daemon: OCI runtime create failed: container_linux.go:349: starting container process caused "exec: \"-l\": executable file not found in $PATH": unknown.
[root@hadoop105 dockerfile]# 

# cmd清理下 -l 替换了CMD ["ls","-a"]命令，-l 不是命令所以报错

测试ENTRYPOINT

[root@hadoop105 dockerfile]# vim dockerfile-cmd-entrypoint
FROM centos
ENTRYPOINT  ["ls","-a"]

[root@hadoop105 dockerfile]# docker build -f dockerfile-cmd-entrypoint -t entrypoint-test .
Sending build context to Docker daemon  4.096kB
Step 1/2 : FROM centos
 ---> 0d120b6ccaa8
Step 2/2 : ENTRYPOINT ["ls","-a"]
 ---> Running in 4fba0aa14213
Removing intermediate container 4fba0aa14213
 ---> 18ab588d15d2
Successfully built 18ab588d15d2
Successfully tagged entrypoint-test:latest
[root@hadoop105 dockerfile]# docker run  18ab588d15d2
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
lost+found
media
mnt
opt
proc
root
run
sbin
srv
sys
tmp
usr
var
# 追加命令是直接拼接在ENTRYPOINT命令的后面
[root@hadoop105 dockerfile]# docker run  18ab588d15d2 -l
total 4
drwxr-xr-x.  17 root root  248 Nov  4 07:06 .
drwxr-xr-x.  17 root root  248 Nov  4 07:06 ..
-rwxr-xr-x.   1 root root    0 Nov  4 07:06 .dockerenv
lrwxrwxrwx.   1 root root    7 May 11  2019 bin -> usr/bin
drwxr-xr-x.   5 root root  340 Nov  4 07:06 dev
drwxr-xr-x.  51 root root 4096 Nov  4 07:06 etc
drwxr-xr-x.   2 root root    6 May 11  2019 home
lrwxrwxrwx.   1 root root    7 May 11  2019 lib -> usr/lib
lrwxrwxrwx.   1 root root    9 May 11  2019 lib64 -> usr/lib64
drwx------.   2 root root    6 Aug  9 21:40 lost+found
drwxr-xr-x.   2 root root    6 May 11  2019 media
drwxr-xr-x.   2 root root    6 May 11  2019 mnt
drwxr-xr-x.   2 root root    6 May 11  2019 opt
dr-xr-xr-x. 291 root root    0 Nov  4 07:06 proc
dr-xr-x---.   2 root root  162 Aug  9 21:40 root
drwxr-xr-x.  11 root root  163 Aug  9 21:40 run
lrwxrwxrwx.   1 root root    8 May 11  2019 sbin -> usr/sbin
drwxr-xr-x.   2 root root    6 May 11  2019 srv
dr-xr-xr-x.  13 root root    0 Oct 28 08:13 sys
drwxrwxrwt.   7 root root  145 Aug  9 21:40 tmp
drwxr-xr-x.  12 root root  144 Aug  9 21:40 usr
drwxr-xr-x.  20 root root  262 Aug  9 21:40 var
[root@hadoop105 dockerfile]# 

实战Tomcat镜像

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

2、编写dockerfile文件,官方命名Dockerfile ,build会自动寻找这个文件，就不需要-f指定了

FROM centos
MAINTAINER gn<[email protected]>

COPY readme.txt  /usr/local/readme.txt            # 复制readme.txt到 /usr/local/路径下（镜像）

ADD  jdk-8u271-linux-x64.tar.gz /usr/local/        # 解压文件到 /usr/local/下
ADD  apache-tomcat-9.0.39.tar.gz /usr/local/

RUN yum -y install vim

ENV MYPATH  /usr/local
WORKDIR $MYPATH

ENV JAVA_HOME  /usr/local/jdk1.8.0_271
ENV CLASSPATH  $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.39
ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.39
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE 8080

CMD /usr/local/apache-tomcat-9.0.39/bin/startup.sh && tail -F /url/local/apache-tomcat-9.0.39/bin/logs/cata
lina.out

3、构建镜像

#  docker build -t diytomcat . # 默认官方文件名，不需要指定文件，自动查找

4、启动镜像（含挂载命令）

 docker run -d -p 9090:8080 --name gntomcat -v /home/tomcat/test:/usr/local/apache-tomcat-9.0.39/webapps/test -v /home/tomcat/tomcatlogs/:/usr/local/apache-tomcat-9.0.39/logs diytomcat

5、访问测试
6、发布项目（由于直接做了卷挂载，我们直接在本地编写项目就可以发布了）

 
 <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>

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>hello,气死人</title>
</head>
<body>
Hello World!<br/>
<%
System.out.println("------my test web logs-------");
%>
</body>
</html>

项目不是成功直接访问

发布镜像

DockerHub

1、地址https://hub.docker.com/ 注册自己的账号
2、确定账号可以登陆
3、在服务器上提交镜像

[root@hadoop105 tomcat]# 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@hadoop105 tomcat]# 

4、登陆完毕，提交镜像 docker push

# push自己的镜像到服务器
[root@hadoop105 tomcat]# docker push diytomcat
The push refers to repository [docker.io/library/diytomcat]
5044b2998ad5: Preparing 
1b5cbed6452e: Preparing 
dbc7f1065df5: Preparing 
34820d2b0f43: Preparing 
291f6e44771a: Preparing 
denied: requested access to the resource is denied  # 拒绝

# push镜像问题？
[root@hadoop105 tomcat]# docker push gaoning/diytomcat:1.0
The push refers to repository [docker.io/gaoning/diytomcat]
An image does not exist locally with the tag: gaoning/diytomcat

# 解决，增加一个tag
[root@hadoop105 tomcat]# docker tag  0ce3408ab2a2 gaoning/tomcat:1.0

#docker push 上去即可（带版本号！！！！！）（自己的虚拟机发布不上去，需要！！！！不要怀疑自己）
[root@hadoop105 ~]# docker push gaoning/tomcat:1.0
The push refers to repository [docker.io/gaoning/tomcat]
5044b2998ad5: Preparing 
1b5cbed6452e: Preparing 
dbc7f1065df5: Preparing 
34820d2b0f43: Preparing 
291f6e44771a: Preparing 

阿里云镜像服务上

1、登陆阿里云
2、找到容器镜像服务https://cr.console.aliyun.com/cn-hangzhou/instances/repositories
3、创建命名空间
4、创建容器镜像
5、查看基本信息

阿里云镜像就参考官方地址

小结

Docker 网络

理解Docker 0

清空所有网络

[root@hadoop105 ~]# docker rm -f $(docker ps -aq)
4331341ed5a0
[root@hadoop105 ~]# docker rmi $(docker images -aq)

在这里插入代码片

三个网络

• 问题: docker 是如果处理容器网络访问的?

# 测试 运行一个tomcat
[root@hadoop105 ~]# docker run -d -P --name tomcat01 tomcat
# 查看容器的内部网络地址 ip addr，发现容器启动的时候会得到一个eth0@if133 ip地址，docker分配!
[root@hadoop105 ~]# docker exec -it tomcat01 ip addr
1: lo: ,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
132: eth0@if133: ,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

# 思考? linux能不能ping通容器内部! 可以 容器内部可以ping通外界吗? 可以!
[root@hadoop105 ~]# 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=1.57 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.134 ms

#linux 可以ping通docker内部容器

原理

1、我们每启动一个docker容器，docker就会给docker容器分配一个ip，我们只要按照了docker， 就会有一个docker0桥接模式，使用的技术是veth-pair技术!

再次测试ip addr

2 、在启动一个容器测试，发现又多了一对网络

[root@hadoop105 ~]# docker run -d -P --name tomcat02 tomcat
3f18121eebf23c66b08d7bdf8e2902542e126709cde85c5c17306581a36a557c
[root@hadoop105 ~]# ip addr

# 我们发现这个容器带来网卡，都是一对对的
# veth-pair 就是一对的虚拟设备接口，他们都是成对出现的，一端连着协议，一端彼此相连 
# 正因为有这个特性 veth-pair 充当一个桥梁，连接各种虚拟网络设备的 
# OpenStac,Docker容器之间的连接，OVS的连接，都是使用evth-pair技术

3、我们来测试下tomcat01和tomcat02是否可以ping通

[root@hadoop105 ~]# docker exec -it tomcat02 ping  172.17.0.2 #让tomcat02ping tomcat01
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.717 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.051 ms
# 容器和容器之间可以ping通

结论:tomcat01和tomcat02公用一个路由器，docker0。
所有的容器不指定网络的情况下，都是docker0路由的，docker会给我们的容器分配一个默认的可用 ip。

小结

Docker使用的是Linux的桥接，宿主机是一个Docker容器的网桥 docker0

Docker中所有网络接口都是虚拟的，虚拟的转发效率高(内网传递文件) 只要容器删除，对应的网桥一对就没了!

（- -link）

思考一个场景:我们编写了一个微服务，database url=ip: 项目不重启，数据ip换了，我们希望可 以处理这个问题，可以通过名字来进行访问容器?

[root@hadoop105 ~]# docker exec -it tomcat02 ping tomca01
ping: tomca01: Name or service not known

# 如何解决
#通过 --link 可以解决网络问题
[root@hadoop105 ~]# docker run -d -P --name tomcat03 --link tomcat02 tomcat
7b7078963be3e8f01645d48a9e1d37ae9be323fc14be900a918bb7d6b85db81f
[root@hadoop105 ~]# 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.094 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=2 ttl=64 time=0.067 ms

# 反向可以ping通吗
[root@hadoop105 ~]# docker exec -it tomcat02 ping tomcat03
ping: tomcat03: Name or service not known

探究：inspect！

tomcat3就是在本地配置了tomcat2的配置

# 查看hosts配置
[root@hadoop105 ~]# docker exec -it tomcat03 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 3f18121eebf2
172.17.0.4      7b7078963be3

（- -link ）本质就是在hosts配置中添加映射
现在使用Docker已经不建议使用–link了!
自定义网络，不适用docker0!
docker0问题:不支持容器名连接访问!

自定义网络

查看所有的docker网络

网络模式
bridge :桥接 docker(默认，自己创建也是用bridge模式)
none :不配置网络，一般不用
host :和所主机共享网络
container :容器网络连通(用得少!局限很大)

测试

# 我们直接启动的命令 --net bridge,而这个就是我们得docker0
# bridge就是docker0
$ docker run -d -P --name tomcat01 tomcat
等价于 => docker run -d -P --name tomcat01 --net bridge tomcat

# docker0，特点:默认，域名不能访问。 --link可以打通连接，但是很麻烦!
# 我们可以 自定义一个网络
# --driver bridge
# --subnet 192.168.0.0/16 192.168.0.2 192.168.255.255
# --gateway 192.168.0.1
[root@hadoop105 ~]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
bc89358d43c378899628a06f13bae2604b458a4f701ae83ca62607771a00b60a
[root@hadoop105 ~]# docker network ls
NETWORK ID          NAME                          DRIVER              SCOPE
852ec3c73a29        bridge                        bridge              local
df2c785b6eb8        docker_mysql_tomcat_default   bridge              local
99667f4e5ee7        docker_nginx_default          bridge              local
b7be53a19190        host                          host                local
bc89358d43c3        mynet                         bridge              local
3c20a294d84e        none                          null                local

[root@hadoop105 ~]# docker network inspect mynet
[
    {
     
        "Name": "mynet",
        "Id": "bc89358d43c378899628a06f13bae2604b458a4f701ae83ca62607771a00b60a",
        "Created": "2020-11-09T15:06:47.825733844+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": {
     }
    }
]
[root@hadoop105 ~]# docker run -d -P --name tomcat-net-01 --net mynet tomcat
1cbf35e7ab088c041c7f750e16974bdeea9e105d61172697938b191d9d51794c
[root@hadoop105 ~]# docker run -d -P --name tomcat-net-02 --net mynet tomcat
4f6721b075d5098248247a23e75a2016cc39e8011c9fb9e8462c06e0dd5b2674
[root@hadoop105 ~]# docker network inspect mynet
[
    {
     
        "Name": "mynet",
        "Id": "bc89358d43c378899628a06f13bae2604b458a4f701ae83ca62607771a00b60a",
        "Created": "2020-11-09T15:06:47.825733844+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": {
     
            "1cbf35e7ab088c041c7f750e16974bdeea9e105d61172697938b191d9d51794c": {
     
                "Name": "tomcat-net-01",
                "EndpointID": "d015f66f9a109e6ebc57c5f38748e9f3e16e445fdb9e8a1f1eba4cd7fad70da1",
                "MacAddress": "02:42:c0:a8:00:02",
                "IPv4Address": "192.168.0.2/16",
                "IPv6Address": ""
            },
            "4f6721b075d5098248247a23e75a2016cc39e8011c9fb9e8462c06e0dd5b2674": {
     
                "Name": "tomcat-net-02",
                "EndpointID": "4c52059c402c34e4dab7974807e83f86d4c33a1cd009ed846a54de97d056c326",
                "MacAddress": "02:42:c0:a8:00:03",
                "IPv4Address": "192.168.0.3/16",
                "IPv6Address": ""
            }
        },
        "Options": {
     },
        "Labels": {
     }
    }
]


# 再次测试ping连接
[root@hadoop105 ~]# docker exec -it tomcat-net-01 ping 192.168.0.3
PING 192.168.0.3 (192.168.0.3) 56(84) bytes of data.
64 bytes from 192.168.0.3: icmp_seq=1 ttl=64 time=0.778 ms
64 bytes from 192.168.0.3: icmp_seq=2 ttl=64 time=0.224 ms
^C
--- 192.168.0.3 ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 16ms
rtt min/avg/max/mdev = 0.224/0.501/0.778/0.277 ms

# 现在不使用 --link也可以ping 名字了
[root@hadoop105 ~]# 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.056 ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.085 ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=3 ttl=64 time=0.110 ms
^C
--- tomcat-net-02 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 43ms
rtt min/avg/max/mdev = 0.056/0.083/0.110/0.024 ms

我们自定义的网络docker帮我们维护好了对应的关系，推荐我们平时这样使用网络! 好处:
redis -不同的集群使用不同的网络，保证集群是安全和健康的
mysql-不同的集群使用不同的网络，保证集群是安全和健康的

网络连通

---

# 测试打通 tomcat01 - mynet
docker network connect mynet tomcat01
# 连通就是将 tomcat01加到 mynet网络 
# 一个容器两个ip(tomcat01)
# 阿里云服务器，公网IP 私网ip

# tomcat01连通
[root@hadoop105 ~]# docker exec -it tomcat01 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.142 ms
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=2 ttl=64 time=0.076 ms

# tomcat02依旧打不通
[root@hadoop105 ~]# docker exec -it tomcat02 ping tomcat-net-01
ping: tomcat-net-01: Name or service not known

结论:假设要跨网络操作别人，就需要使用docker network connect 连通!

实战：部署Redis集群

# 创建网卡
docker network create redis --subnet 172.16.0.0/16
# 通过脚本创建六个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.16.0.1${
     port} 
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
done



# 通过脚本运行六个redis
docker run -p 637${
     port}:6379 -p 1667${
     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.16.0.1${
     port} redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

# 也可一个一个启动，方便理解 ，比如：以此类推6个
docker run -p 6371:6379 -p 16671: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.16.0.11 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

docker run -p 6372:6379 -p 16672:16379 --name redis-2 \
-v /mydata/redis/node-2/data:/data \
-v/mydata/redis/node-2/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.16.0.12 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

docker run -p 6373:6379 -p 16673:16379 --name redis-3 \
-v /mydata/redis/node-3/data:/data \
-v/mydata/redis/node-3/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.16.0.13 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

docker run -p 6374:6379 -p 16674:16379 --name redis-4 \
-v /mydata/redis/node-4/data:/data \
-v/mydata/redis/node-4/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.16.0.14 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

docker run -p 6375:6379 -p 16675:16379 --name redis-5 \
-v /mydata/redis/node-5/data:/data \
-v/mydata/redis/node-5/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.16.0.15 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

docker run -p 6376:6379 -p 16676:16379 --name redis-6 \
-v /mydata/redis/node-6/data:/data \
-v/mydata/redis/node-6/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.16.0.16 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf


# docker exec -it redis-1 /bin/sh #redis默认没有bash
[root@hadoop105 conf]# docker exec -it redis-1 /bin/sh
/data # ls
appendonly.aof  nodes.conf
/data # redis-cli --cluster create 172.16.0.11:6379 172.16.0.12:6379 172.16.0.13:6379 172.16.0.14:6379 17
2.16.0.15:6379 172.16.0.16:6379 --cluster-replicas 1
>>> Performing hash slots allocation on 6 nodes...
Master[0] -> Slots 0 - 5460
Master[1] -> Slots 5461 - 10922
Master[2] -> Slots 10923 - 16383
Adding replica 172.16.0.15:6379 to 172.16.0.11:6379
Adding replica 172.16.0.16:6379 to 172.16.0.12:6379
Adding replica 172.16.0.14:6379 to 172.16.0.13:6379
M: ad892d7b834d07ba97cfffe4deef4c3276459f30 172.16.0.11:6379
   slots:[0-5460] (5461 slots) master
M: 0b47f45a329a709a355ef586ff0730e7b7f3d865 172.16.0.12:6379
   slots:[5461-10922] (5462 slots) master
M: 066b424f84ebddabf27836e6c98e5736bf8db8ec 172.16.0.13:6379
   slots:[10923-16383] (5461 slots) master
S: 48c0bee5a8a20e0fc83749aea238466d7859d384 172.16.0.14:6379
   replicates 066b424f84ebddabf27836e6c98e5736bf8db8ec
S: 49630572dbd845bd88e73c229a775966a6288d92 172.16.0.15:6379
   replicates ad892d7b834d07ba97cfffe4deef4c3276459f30
S: e947b3fafefa90f69d3f8f9fbac42c5866b63079 172.16.0.16:6379
   replicates 0b47f45a329a709a355ef586ff0730e7b7f3d865
Can I set the above configuration? (type 'yes' to accept): yes
>>> Nodes configuration updated
>>> Assign a different config epoch to each node
>>> Sending CLUSTER MEET messages to join the cluster
Waiting for the cluster to join
....
>>> Performing Cluster Check (using node 172.16.0.11:6379)
M: ad892d7b834d07ba97cfffe4deef4c3276459f30 172.16.0.11:6379
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
S: 49630572dbd845bd88e73c229a775966a6288d92 172.16.0.15:6379
   slots: (0 slots) slave
   replicates ad892d7b834d07ba97cfffe4deef4c3276459f30
S: 48c0bee5a8a20e0fc83749aea238466d7859d384 172.16.0.14:6379
   slots: (0 slots) slave
   replicates 066b424f84ebddabf27836e6c98e5736bf8db8ec
M: 066b424f84ebddabf27836e6c98e5736bf8db8ec 172.16.0.13:6379
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
S: e947b3fafefa90f69d3f8f9fbac42c5866b63079 172.16.0.16:6379
   slots: (0 slots) slave
   replicates 0b47f45a329a709a355ef586ff0730e7b7f3d865
M: 0b47f45a329a709a355ef586ff0730e7b7f3d865 172.16.0.12:6379
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.

docker搭建redis集群完成

SpringBoot项目打包Docker镜像

1、构建SpringBoot项目
2、打包运行

mvn package

3、编写dockerfile

FROM java:8
COPY *.jar /app.jar
CMD ["--server.port=8080"]
EXPOSE 8080
ENTRYPOINT ["java","-jar","app.jar"]

4、构建镜像

# 1.复制jar和DockerFIle到服务器 # 2.构建镜像
$ docker build -t xxxxx:xx .

5、发布运行