玩命加载中 . . .

Docker学习笔记

Docker
Docker
发布日期: 2020-11-26
作者: 勇也很努力
文章字数: 6.7k
阅读时长: 33 分

学习视频链接：B站 遇见狂神说

一、概述

Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的镜像中，然后发布到任何流行的 Linux或Windows 机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口。

docker是基于Go语言开发的。

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

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

仓库地址：https://hub.docker.com/

容器化技术

容器技术:有效的将单个操作系统的资源划分到孤立的组中，以便更好的在孤立的组之间平衡有冲突的资源使用需求，这种技术就是容器技术。

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

Docker与虚拟机技术的区别：

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

DevOps（开发、运维）

应用更快速的交互和部署。

Docker，打包镜像，发布测试，一键运行。

更便捷的升级和扩容。

更简单的系统运维。

更高效的计算资源利用。

Docker是内核级别的虚拟化，可以在一个物理机上运行很多容器实例。服务器的性能可以被压榨到极致。

二、安装

Docker的基本组成

Docker Architecture Diagram

镜像（image）

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

容器（container）

Docker利用容器技术，独立运行一个或一个组应用，通过镜像来创建的。

启动、停止、删除=>基本命令

仓库（repository）

仓库就是存放镜像的地方。

仓库分为共有仓库和私有仓库。

安装Docker

环境准备

CentOS7.8、XShell

环境查看

# 系统内核需升级到2.10以上
[root@lskj ~]# uname -r
3.10.0-1127.19.1.el7.x86_64

安装

文档地址：https://docs.docker.com/engine/install/centos/

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

yum install docker-ce docker-ce-cli containerd.io

docker-ce社区版，ee是企业版。

5、启动docker

systemctl start docker

6、查看docker是否安装成功

docker version

7、hello-world测试

docker run hello-world

hello-world

hello-world流程

8、查看一下下载的这个hello-world镜像

[root@lskj ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
hello-world         latest              bf756fb1ae65        10 months ago       13.3kB
[root@lskj ~]#

卸载docker

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

阿里云镜像加速

1、登录阿里云后，进入控制台，点击产品与服务。

容器镜像服务

2、首次使用，需要开通，设置Registry登录密码。

3、找到镜像加速地址。

镜像加速地址

4、配置使用。

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

底层原理

Docker是一个Client-Server结构的系统，Docker的守护进程服务运行在主机上。通过Socket丛客户端访问。

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

Docker为什么比VM快？

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

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

当新建一个容器时，Docker不需要和虚拟机一样重新加载一个操作系统，避免了引导、加载操作系统内核这个比较费时费资源的过程，当新建一个虚拟机时，虚拟机软件需要加载Guest OS，这个新建过程是分钟级别的，而Docker由于直接利用宿主机的操作系统则省略了这个过程，因此新建一个Docker容器只需要几秒钟。

Docker容器 虚拟机（VM）
操作系统 与宿主机共享OS 宿主机OS上运行宿主机OS
存储大小 镜像小，便于存储与传输 镜像庞大（vmdk等）
运行性能 几乎无额外性能损失 操作系统额外的cpu、内存消耗
移植性 轻便、灵活、适用于Linux 笨重、与虚拟化技术耦合度高
硬件亲和性 面向软件开发者 面向硬件运维者

三、Docker常用命令

帮助命令

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

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

镜像命令

docker images

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

[root@lskj ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
hello-world         latest              bf756fb1ae65        10 months ago       13.3kB

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

可选项

Options:
  -a, --all             列出所有的镜像
      --digests         Show digests
  -f, --filter filter   Filter output based on conditions provided
      --format string   Pretty-print images using a Go template
      --no-trunc        Don't truncate output
  -q, --quiet           只显示镜像的id

搜索镜像

[root@lskj ~]# docker search mysql
NAME                              DESCRIPTION                                     STARS               OFFICIAL            AUTOMATED
mysql                             MySQL is a widely used, open-source relation…   10202               [OK]                
mariadb                           MariaDB is a community-developed fork of MyS…   3753                [OK]                
mysql/mysql-server                Optimized MySQL Server Docker images. Create…   744                                     [OK]

可选项

Options:
  -f, --filter filter   Filter output based on conditions provided
      --format string   Pretty-print search using a Go template
      --limit int       Max number of search results (default 25)
      --no-trunc        Don't truncate output

通过搜藏来过滤

--filter=STARS=3000 #搜索出来的镜像就是STARS大于3000的

[root@lskj ~]# docker search mysql --filter=STARS=3000
NAME                DESCRIPTION                                     STARS               OFFICIAL            AUTOMATED
mysql               MySQL is a widely used, open-source relation…   10202               [OK]                
mariadb             MariaDB is a community-developed fork of MyS…   3753                [OK]

docker pull

下载镜像

docker pull 镜像名[:tag]

[root@lskj ~]# docker pull mysql
Using default tag: latest #如果不写tag，默认就是latest
latest: Pulling from library/mysql
852e50cd189d: Pull complete  #分层下载，docker image的核心，联合文件系统
29969ddb0ffb: Pull complete 
a43f41a44c48: Pull complete 
5cdd802543a3: Pull complete 
b79b040de953: Pull complete 
938c64119969: Pull complete 
7689ec51a0d9: Pull complete 
a880ba7c411f: Pull complete 
984f656ec6ca: Pull complete 
9f497bce458a: Pull complete 
b9940f97694b: Pull complete 
2f069358dc96: Pull complete 
Digest: sha256:4bb2e81a40e9d0d59bd8e3dc2ba5e1f2197696f6de39a91e90798dd27299b093 #签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest #真实地址

docker pull mysql == docker pull docker.io/library/mysql:latest

指定版本下载

[root@lskj ~]# docker pull mysql:5.7
5.7: Pulling from library/mysql
852e50cd189d: Already exists 
29969ddb0ffb: Already exists 
a43f41a44c48: Already exists 
5cdd802543a3: Already exists 
b79b040de953: Already exists 
938c64119969: Already exists 
7689ec51a0d9: Already exists 
36bd6224d58f: Pull complete 
cab9d3fa4c8c: Pull complete 
1b741e1c47de: Pull complete 
aac9d11987ac: Pull complete 
Digest: sha256:8e2004f9fe43df06c3030090f593021a5f283d028b5ed5765cc24236c2c4d88e
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7

docker rmi

删除镜像

[root@lskj ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
mysql               5.7                 ae0658fdbad5        2 days ago          449MB
mysql               latest              dd7265748b5d        2 days ago          545MB
hello-world         latest              bf756fb1ae65        10 months ago       13.3kB
[root@lskj ~]# docker rmi -f dd7265748b5d
Untagged: mysql:latest
Untagged: mysql@sha256:4bb2e81a40e9d0d59bd8e3dc2ba5e1f2197696f6de39a91e90798dd27299b093
Deleted: sha256:dd7265748b5dc3211208fb9aa232cef8d3fefd5d9a2a80d87407b8ea649e571c
Deleted: sha256:aac9a624212bf416c3b41a62212caf12ed3c578d6b17b0f15be13a7dab56628d
Deleted: sha256:1bf3ce09276e9e128108b166121e5d04abd16e7de7473b53b3018c6db0cf23ff
Deleted: sha256:24c6444cea460c3cc2f4e0385e3e97819a0672a54a361921f95d4582583abd59
Deleted: sha256:77585ebe3eaa035694084b3c5937fe82b8972aae1e6c6070fc4d7bc391d10928
Deleted: sha256:1cfd539163ceb17f7bb85a0da968714fe9258b75dbf73f5ad45392a45cfd34b7
[root@lskj ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
mysql               5.7                 ae0658fdbad5        2 days ago          449MB
hello-world         latest              bf756fb1ae65        10 months ago       13.3kB
[root@lskj ~]# docker rmi -f $(docker images -aq)
Untagged: mysql:5.7
Untagged: mysql@sha256:8e2004f9fe43df06c3030090f593021a5f283d028b5ed5765cc24236c2c4d88e
Deleted: sha256:ae0658fdbad5fb1c9413c998d8a573eeb5d16713463992005029c591e6400d02
Deleted: sha256:a2cf831f4221764f4484ff0df961b54f1f949ed78220de1b24046843c55ac40f
Deleted: sha256:0a7adcc95a91b1ec2beab283e0bfce5ccd6df590bd5a5e894954fcf27571e7f5
Deleted: sha256:0fae465cbacf7c99aa90bc286689bc88a35d086f37fd931e03966d312d5dfb10
Deleted: sha256:23af125b9e54a94c064bdfacc2414b1c8fba288aff48308e8117beb08b38cb19
Deleted: sha256:c37f414ac8d2b5e5d39f159a6dffd30b279c1268f30186cee5da721e451726ea
Deleted: sha256:955b3c214bccf3ee2a7930768137fd7ed6a72677334be67a07c78a622abd318a
Deleted: sha256:a2e35a0fdb20100365e2fb26c65357fcf926ac7990bf9074a51cbac5a8358d7e
Deleted: sha256:8c3a028fc66f360ce6ce6c206786df68fac4c24257474cbe4f67eda0ac21efd6
Deleted: sha256:0a6d37fabaceb4faa555e729a7d97cb6ee193cb97789a213907a3d3c156d7e35
Deleted: sha256:579519c51de1afe1e29d284b1741af239a307975197cf6ce213a70068d923231
Deleted: sha256:f5600c6330da7bb112776ba067a32a9c20842d6ecc8ee3289f1a713b644092f8
Untagged: hello-world:latest
Untagged: hello-world@sha256:e7c70bb24b462baa86c102610182e3efcb12a04854e8c582838d92970a09f323
Deleted: sha256:bf756fb1ae65adf866bd8c456593cd24beb6a0a061dedf42b26a993176745f6b
[root@lskj ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
[root@lskj ~]#

docker rmi -f 镜像id删除指定的镜像。

docker rmi -f 镜像id 镜像id 镜像id删除多个镜像。

docker rmi -f $(docker images -aq)删除全部的镜像。

容器命令

有了镜像才可以创建容器

下载一个centos镜像进行测试。

[root@lskj ~]# docker pull centos
Using default tag: latest
latest: Pulling from library/centos
3c72a8ed6814: Pull complete 
Digest: sha256:76d24f3ba3317fa945743bb3746fbaf3a0b752f10b10376960de01da70685fbd
Status: Downloaded newer image for centos:latest
docker.io/library/centos:latest

新建容器并启动

docker run [可选参数] image

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

测试

# 启动并进入容器
[root@lskj /]# docker run -it centos /bin/bash
[root@5ea79d7e4aaa /]# ls #查看容器内的centos
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
#从容器中退回主机
[root@5ea79d7e4aaa /]# exit 
exit
[root@lskj /]# ls
bin  boot  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var

列出所有的运行的容器

# docker ps 命令
     #列出当前正在运行的容器
-a   #列出当前正在运行的容器，并带出历史运行过的容器
-n=? #显示最近创建的容器
-q   #只显示容器的编号
[root@lskj /]# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
[root@lskj /]# docker ps -a
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                          PORTS               NAMES
5ea79d7e4aaa        centos              "/bin/bash"         3 minutes ago       Exited (0) About a minute ago                       practical_pasteur
0126d6ae66c8        bf756fb1ae65        "/hello"            14 hours ago        Exited (0) 14 hours ago                             dreamy_williamson

退出容器

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@lskj /]# docker run -d centos
d50f3d4deb0f29e7b2e11b27f4ff4bcef7fb1084b87485236544516490b978e9
[root@lskj /]# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
[root@lskj /]#

问题

docker ps发现centos停止了。

docker容器使用后台运行，就必须要有一个前台进程，docker发现没有应用，就会自动停止。

nginx，容器启动后，发现自己没有提供服务，就会立刻停止，就是没有程序了。

查看日志

docker logs -f -t --tail number 容器id   
#如果没有显示日志，编写一段shell脚本，进行测试你
[root@lskj /]# docker run -d centos /bin/sh -c "while true;do echo lskj;sleep 1;done"
46b9b0ea42617276eb5dc975abb489954a306c67fbec3586df75432dfc0e34ea
[root@lskj /]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS               NAMES
46b9b0ea4261        centos              "/bin/sh -c 'while t…"   3 seconds ago       Up 3 seconds                            kind_lamport
[root@lskj /]#


# 显示日志
-tf            #显示日志
--tail number  #要显示日志条数
[root@lskj /]# docker logs -f -t --tail 10 46b9b0ea4261

查看容器中进程信息

# 命令：docker top 容器id
[root@lskj /]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS               NAMES
46b9b0ea4261        centos              "/bin/sh -c 'while t…"   6 minutes ago       Up 6 minutes                            kind_lamport
[root@lskj /]# docker top 46b9b0ea4261
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                14814               14797               0                   11:13               ?                   00:00:00            /bin/sh -c while true;do echo lskj;sleep 1;done
root                15308               14814               0                   11:20               ?                   00:00:00            /usr/bin/coreutils --coreutils-prog-shebang=sleep /usr/bin/sleep 1
[root@lskj /]#

查看镜像的元数据

#命令：docker inspect 容器id
[root@lskj /]# docker inspect 46b9b0ea4261
[
    {
        "Id": "46b9b0ea42617276eb5dc975abb489954a306c67fbec3586df75432dfc0e34ea",
        "Created": "2020-11-23T03:13:48.143980583Z",
        "Path": "/bin/sh",
        "Args": [
            "-c",
            "while true;do echo lskj;sleep 1;done"
        ],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 14814,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2020-11-23T03:13:48.42067532Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:0d120b6ccaa8c5e149176798b3501d4dd1885f961922497cd0abef155c869566",
        "ResolvConfPath": "/var/lib/docker/containers/46b9b0ea42617276eb5dc975abb489954a306c67fbec3586df75432dfc0e34ea/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/46b9b0ea42617276eb5dc975abb489954a306c67fbec3586df75432dfc0e34ea/hostname",
        "HostsPath": "/var/lib/docker/containers/46b9b0ea42617276eb5dc975abb489954a306c67fbec3586df75432dfc0e34ea/hosts",
        "LogPath": "/var/lib/docker/containers/46b9b0ea42617276eb5dc975abb489954a306c67fbec3586df75432dfc0e34ea/46b9b0ea42617276eb5dc975abb489954a306c67fbec3586df75432dfc0e34ea-json.log",
        "Name": "/kind_lamport",
        "RestartCount": 0,
        "Driver": "overlay2",
        "Platform": "linux",
        "MountLabel": "",
        "ProcessLabel": "",
        "AppArmorProfile": "",
        "ExecIDs": null,
        "HostConfig": {
            "Binds": null,
            "ContainerIDFile": "",
            "LogConfig": {
                "Type": "json-file",
                "Config": {}
            },
            "NetworkMode": "default",
            "PortBindings": {},
            "RestartPolicy": {
                "Name": "no",
                "MaximumRetryCount": 0
            },
            "AutoRemove": false,
            "VolumeDriver": "",
            "VolumesFrom": null,
            "CapAdd": null,
            "CapDrop": null,
            "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/5542d30147b91dcdb6a661d83c96e557e7bf718a2c0a25443fa410ba32391675-init/diff:/var/lib/docker/overlay2/06551e2d5cbd37fe1dd01d044c604d63c25a5e5b00ff1e9dcd22cd5b273f1e81/diff",
                "MergedDir": "/var/lib/docker/overlay2/5542d30147b91dcdb6a661d83c96e557e7bf718a2c0a25443fa410ba32391675/merged",
                "UpperDir": "/var/lib/docker/overlay2/5542d30147b91dcdb6a661d83c96e557e7bf718a2c0a25443fa410ba32391675/diff",
                "WorkDir": "/var/lib/docker/overlay2/5542d30147b91dcdb6a661d83c96e557e7bf718a2c0a25443fa410ba32391675/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "46b9b0ea4261",
            "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 lskj;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": "bf7877c7d65c141262144d36f8f84055335dee25ee1202450f8a42f8d46985a9",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/bf7877c7d65c",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "660ee337634eb908d4ebe5ad0442b0a9c7a5103ce749b842f6fe4837c869c899",
            "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": "ee56590e65cf6f8e71efb6c797a16174e72e5696f5bd1f76ecf32a387f69864e",
                    "EndpointID": "660ee337634eb908d4ebe5ad0442b0a9c7a5103ce749b842f6fe4837c869c899",
                    "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@lskj /]#

进入当前正在运行的容器

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

#命令：docker exec -it 容器id bash/shell
[root@lskj /]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS               NAMES
46b9b0ea4261        centos              "/bin/sh -c 'while t…"   14 minutes ago      Up 14 minutes                           kind_lamport
[root@lskj /]# docker exec -it 46b9b0ea4261 /bin/bash
[root@46b9b0ea4261 /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
[root@46b9b0ea4261 /]# ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 03:13 ?        00:00:00 /bin/sh -c while true;do echo lskj;sleep 1;done
root       891     0  0 03:28 pts/0    00:00:00 /bin/bash
root       957     1  0 03:29 ?        00:00:00 /usr/bin/coreutils --coreutils-prog-shebang=sleep /usr/bin/sleep 1
root       958   891  0 03:29 pts/0    00:00:00 ps -ef
[root@46b9b0ea4261 /]#

#方式二：docker attach 容器id
[root@lskj /]# docker attach 46b9b0ea4261
正在执行当前的代码（上面编写的shell脚本，执行是一个死循环），此时使用快捷键之类的无法退出，可复制会话，杀死docker attach进程。
[root@lskj ~]# pkill -9 -f 'docker.*attach'
[root@lskj ~]#

docker exec进入容器后，开启一个新的终端，可以在里面操作（常用）。

docker attach进入容器正在执行的终端，不会启动新的进程。

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

#命令：docker cp 容器id:容器内路径 目的地主机路径
[root@lskj /]# docker run -it centos /bin/bash
[root@2510245c778d /]# [root@lskj /]# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
2510245c778d        centos              "/bin/bash"         11 seconds ago      Up 11 seconds                           musing_kilby
#查看当前主机home目录下的文件
[root@lskj /]# cd /home
[root@lskj home]# ls
#进入docker容器内部
[root@lskj home]# docker attach 2510245c778d
[root@2510245c778d /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
[root@2510245c778d /]# cd /home/
[root@2510245c778d home]# ls
#在容器home目录下创建一个test文件
[root@2510245c778d home]# touch test
[root@2510245c778d home]# ls
test
[root@2510245c778d home]# exit
exit
[root@lskj home]# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
#将文件拷贝到主机上
[root@lskj home]# docker cp 2510245c778d:/home/test /home
[root@lskj home]# ls
test
[root@lskj home]#

四、部署nginx

1、搜索镜像。（可以在dockerhub搜索查看）

docker search nginx

2、下载镜像。

docker pull nginx

3、运行测试。

# -d 后台运行  --name 给容器命名  -p 宿主机端口:容器内部端口
[root@lskj /]# docker run -d --name nginxTest -p 8080:80 nginx
8e01d8de2d93004ec187abfdac32c7ea41ed1fb55a825a554e9796d0fd9b48ca
[root@lskj /]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                  NAMES
8e01d8de2d93        nginx               "/docker-entrypoint.…"   38 seconds ago      Up 38 seconds       0.0.0.0:8080->80/tcp   nginxTest
[root@lskj /]# curl localhost:8080

4、进入容器。

[root@lskj /]# docker exec -it nginxTest /bin/bash
root@8e01d8de2d93:/# cd /etc/nginx
root@8e01d8de2d93:/etc/nginx# ls
conf.d    fastcgi_params    koi-utf  koi-win  mime.types  modules  nginx.conf  scgi_params    uwsgi_params  win-utf
root@8e01d8de2d93:/etc/nginx#

五、部署Tomact

官方的使用，一般用来测试，用完即删除。

docker run -it --rm tomcat:9.0

1、下载。

docker pull tomcat:9.0
#最新版下载
docker pull tomcat

2、启动。

docker run -d -p 80:8080 --name tomcatTest tomcat

3、进入容器。

[root@lskj /]# docker exec -it tomcatTest /bin/bash
root@d08553edb696:/usr/local/tomcat# ls -la
total 176
drwxr-xr-x 1 root root  4096 Nov 19 06:16 .
drwxr-xr-x 1 root root  4096 Nov 19 06:12 ..
-rw-r--r-- 1 root root 18982 Nov 12 15:41 BUILDING.txt
-rw-r--r-- 1 root root  5409 Nov 12 15:41 CONTRIBUTING.md
-rw-r--r-- 1 root root 57092 Nov 12 15:41 LICENSE
-rw-r--r-- 1 root root  2333 Nov 12 15:41 NOTICE
-rw-r--r-- 1 root root  3257 Nov 12 15:41 README.md
-rw-r--r-- 1 root root  6898 Nov 12 15:41 RELEASE-NOTES
-rw-r--r-- 1 root root 16507 Nov 12 15:41 RUNNING.txt
drwxr-xr-x 2 root root  4096 Nov 19 06:16 bin
drwxr-xr-x 1 root root  4096 Nov 23 06:02 conf
drwxr-xr-x 2 root root  4096 Nov 19 06:16 lib
drwxrwxrwx 1 root root  4096 Nov 23 06:02 logs
drwxr-xr-x 2 root root  4096 Nov 19 06:16 native-jni-lib
drwxrwxrwx 2 root root  4096 Nov 19 06:16 temp
drwxr-xr-x 2 root root  4096 Nov 19 06:16 webapps
drwxr-xr-x 7 root root  4096 Nov 12 15:38 webapps.dist
drwxrwxrwx 2 root root  4096 Nov 12 15:35 work
root@d08553edb696:/usr/local/tomcat# cd webapps
root@d08553edb696:/usr/local/tomcat/webapps# ls
root@d08553edb696:/usr/local/tomcat/webapps#

此时，发现Linux命令少了，也没有webapps。这是因为阿里云镜像的原因，默认是最小的镜像，所有不必要的都删除掉了，保证最小可运行的环境。（现在外网访问会报404，若需要，可执行命令cp -r webapps.dist/* webapps将webapps.dist下的文件复制到webapps下，即可正常访问）

六、部署ES

ES（elastic search）暴露的端口很多，十分耗内存。

ES的数据一般需要放置到安全目录，挂载。

# --net somnetwork 网络配置
docker run -d --name elasticsearch --net somenetwork -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:tag

#下载启动elasticsearch
docker run -d --name elasticsearch  -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2
#启动之后，Linux可能会卡 docker stats查看CPU的状态
docker stats

#测试一下es是否成功
[root@lskj /]# curl localhost:9200
{
  "name" : "7fa5c06dc5df",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "DecIaQ03RmG_gGib0baOWg",
  "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"
}
[root@lskj /]#

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

使用Kibana连接ES

可视化

portainer

Docker图形化界面管理工具。提供一个后台面板。

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

访问测试：http://ip:8080/

Rancher(CI/CD再用)

七、Docker镜像

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

所有的应用，直接打包docker镜像，就可以直接跑起来了。

怎样得到镜像？

  • 从远程仓库下载
  • 拷贝
  • 制作镜像DockerFile

Docker镜像加载原理

UnionFS（联合文件系统）

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

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

Docker镜像加载原理

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

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

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

在VMware中使用的CentOS是都是几个G，为什么Docker里只有几百M？

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

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

分层理解

下载一个镜像时，从下载日志可以看出是一层一层地下载。

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

例如，基于Ubuntu 16.04创建一个新的镜像，这就是新镜像的第一层。如果在该镜像中添加Python包，就会在基础镜像层之上创建第二个镜像层。如果继续添加一个安全补丁，就会创建第三个镜像层。

在添加额外的镜像层的同时，镜像始终保持是当前所有镜像的组合。例如，每个镜像层包含三个文件，而镜像包含了来自两个镜像层的6个文件。

下图在外部看来整个镜像只有6个文件，这是因为最上层中的文件7是文件5的一个更新版。

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

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

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

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

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

特点

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

这一层就是通常所说的容器层，容器之下的都叫镜像层。

commit镜像

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

docker commit -m="提交的描述信息" -a="作者" 容器id 目标镜像名:[TAG]

测试

#启动一个默认的Tomcat
docker run -it -p 8080:8080 tomcat
#默认的Tomcat没有webapps应用，需拷贝webapps.dist下的文件到webapps
docker exec -it tomcatTest /bin/bash
cd webapps
ls
cd ..
cp -r webapps.dist/* webapps

将操作过的容器通过commit提交为一个镜像tomcat02，后续使用修改过的镜像即可，这就是自定义修改的镜像。

[root@lskj ~]# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS                    NAMES
caa0c361cd59        tomcat              "catalina.sh run"   7 minutes ago       Up 7 minutes        0.0.0.0:8080->8080/tcp   jovial_chebyshev
[root@lskj ~]# docker commit -a="lskj" -m="add webapps app" caa0c361cd59 tomcatTest:1.0
invalid reference format: repository name must be lowercase
[root@lskj ~]# docker commit -a="lskj" -m="add webapps app" caa0c361cd59 tomcat02:1.0
sha256:963f5b061d831efcf953d3252b13cd82bb28c2581f25593117c22830f2c19fc8
[root@lskj ~]# docker images
REPOSITORY            TAG                 IMAGE ID            CREATED             SIZE
tomcat02              1.0                 963f5b061d83        8 seconds ago       654MB
tomcat                9.0                 e0bd8b34b4ea        5 days ago          649MB
tomcat                latest              e0bd8b34b4ea        5 days ago          649MB
redis                 latest              74d107221092        6 days ago          104MB
nginx                 latest              daee903b4e43        6 days ago          133MB
centos                latest              0d120b6ccaa8        3 months ago        215MB
portainer/portainer   latest              62771b0b9b09        4 months ago        79.1MB
elasticsearch         7.6.2               f29a1ee41030        8 months ago        791MB
[root@lskj ~]#

八、容器数据卷

docker将应用和环境打包成一个镜像，如果数据都在容器中，容器被删除，数据就会丢失。希望mysql数据可以存储咋本地。

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

这就是卷技术。也就是目录的挂载，将容器内的目录，挂载到Linux上。

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

使用数据卷

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

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

测试：

[root@lskj home]# docker run -it -v /home/test:/home/ centos /bin/bash
[root@e8fd1fc54022 /]
#启动之后，复制会话，通过docker inspect 容器id 查看容器详细信息
[root@lskj test]# docker inspect e8fd1fc54022
...
        "Mounts": [  #挂载 -v 卷
            {
                "Type": "bind",
                "Source": "/home/test",  #主机内地址
                "Destination": "/home",  #docker容器内的地址
                "Mode": "",
                "RW": true,
                "Propagation": "rprivate"
            }
        ],

...

测试文件的同步：

1、停止容器

2、宿主机上修改文件

3、启动容器

4、容器内的数据依旧是同步的

以后修改只需要在本地修改即可，容器内会自动同步。

安装Mysql

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

#运行容器，需要做数据挂载。 安装启动mysql，需要配置密码
# -d 后台运行
# -p 端口映射
# -v 卷挂载
# -e 环境配置
# --name 容器名字
#官方测试：docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag
[root@lskj home]# docker run -d -p 8080:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=root --name mysql01 mysql:5.7
d150915a1b29d8c4a4999f1fae84bcc6b1b618835e0515f410b49abd22f17360

#启动成功后，可在本地测试连接
mysql -h 公网ip -uroot -P 8080 -proot
#本地创建数据库
mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
4 rows in set (0.05 sec)

mysql> create database test;
Query OK, 1 row affected (0.05 sec)

mysql>

Linux查看映射的路径：

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

具名和匿名挂载

匿名挂载：

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

#查看所有卷的情况
docker volume ls

[root@lskj ~]# docker volume ls
DRIVER              VOLUME NAME
local               2b50e0b7719627983833949e6c713f88d3375ab6ddc83da773e2193e1a1f9b08
local               2bd8935c5fea24f21bef8438c10d769dd4c02edf3481724e1c8cb5e2669582e1
local               d3d6b7d6d26a670e30e9c97b0dcaed03212b148427e9468cbc07a39246cdb3b2
[root@lskj ~]#
#这里的这种就是匿名挂载，因为在-v时只写了容器内的路径，没有写容器外的路径

具名挂载：

[root@lskj home]# docker run -d -P --name nginx02 -v test-nginx:/etc/nginx nginx
f4d7f0da4443ca8d724d709055bb502cdf189e87b5f120a1b944c21b4d4e6457
[root@lskj home]# docker volume ls
DRIVER              VOLUME NAME
local               2b50e0b7719627983833949e6c713f88d3375ab6ddc83da773e2193e1a1f9b08
local               2bd8935c5fea24f21bef8438c10d769dd4c02edf3481724e1c8cb5e2669582e1
local               d3d6b7d6d26a670e30e9c97b0dcaed03212b148427e9468cbc07a39246cdb3b2
local               test-nginx
[root@lskj home]#

通过-v 卷名:容器内路径。

查看一下这个卷

[root@lskj home]# docker volume inspect test-nginx
[
    {
        "CreatedAt": "2020-11-25T10:11:19+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/test-nginx/_data",
        "Name": "test-nginx",
        "Options": null,
        "Scope": "local"
    }
]
[root@lskj home]#

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

[root@lskj home]# cd /var/lib/docker/volumes
[root@lskj volumes]# ls
2b50e0b7719627983833949e6c713f88d3375ab6ddc83da773e2193e1a1f9b08  metadata.db
2bd8935c5fea24f21bef8438c10d769dd4c02edf3481724e1c8cb5e2669582e1  test-nginx
d3d6b7d6d26a670e30e9c97b0dcaed03212b148427e9468cbc07a39246cdb3b2
[root@lskj volumes]# cd test-nginx/
[root@lskj test-nginx]# ls
_data
[root@lskj test-nginx]# cd _data/
[root@lskj _data]# ls
conf.d  fastcgi_params  koi-utf  koi-win  mime.types  modules  nginx.conf  scgi_params  uwsgi_params  win-utf
[root@lskj _data]#

通过具名挂载可以方便找到一个卷，通常情况下使用的是具名挂载。

怎样区分是具名挂载、匿名挂载，还是指定路径挂载？

  • -v 容器内路径匿名挂载
  • -v 卷名:容器内路径具名挂载
  • -v /宿主机路径:容器内路径指定路径挂载

拓展

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

[root@lskj home]# docker run -d -P --name nginx02 -v test-nginx:/etc/nginx:ro nginx
[root@lskj home]# docker run -d -P --name nginx02 -v test-nginx:/etc/nginx:rw nginx

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

初始Dockerfile

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

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

#创建一个dockerfile文件dockerfile01
# dockerfile01中的内容，指定(大写) 参数
FROM centos
VOLUME ["volume01","volume02"]

CMD echo "-----end-----"
CMD /bin/bash
#这里的每个命令，就是镜像的一层。

启动自定义的容器：

[root@lskj docker-test-volume]# docker run -it f9c2cfe22856 /bin/bash
[root@1b04e3544ea3 /]#

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

查看一下挂载的路径：

测试：

数据卷容器

启动三个容器，通过上面自定义的镜像启动。

删除docker01，查看docker02和docker03

多个mysql实现数据共享。

[root@lskj home]# docker run -d -p 8080:3306 -v /etc/mysql/conf.d -v /var/lib/mysql -e MYSQL_ROOT_PASSWORD=root --name mysql01 mysql:5.7

[root@lskj home]# docker run -d -p 8080:3306 -e MYSQL_ROOT_PASSWORD=root --name mysql02 --volumes-from mysql01 mysql:5.7

结论：

容器之间配置信息的传递，数据卷的生命周期一直持续到没有容器使用为止。

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

九、DockerFile

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

构建步骤：

  • 编写一个dockerfile文件
  • docker build构建成为一个镜像
  • docker run运行镜像
  • docker push发布镜像

DockerFile构建过程

基础知识

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

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

3、#表示注释。

4、每一个指定都会创建提交一个新的镜像层。

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

步骤：开发、部署、运维

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

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

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

DockerFile的指令

FROM基础镜像，一切从这里开始构建。（指定基础镜像）

MAINTAINER镜像是谁写的，姓名+邮箱（指定维护者信息）

RUN镜像构建时，需要运行的命令（你想让它做什么，在命令前面加上RUN即可）

ADDcopy文件，会自动解压

WORKDIR设置镜像的工作目录

VOLUME设置卷，挂载主机目录

EXPOSE指定对外的端口，暴露端口

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

ENTRYPOINT指定容器启动时，要运行的命令，可以追加命令

ONBUILD当构建一个被继承DockerFile时，就会运行ONBUILD指令（触发指令）

COPY类似ADD，将文件拷贝到镜像中

ENV构建时，设置环境变量

构建自已的Centos

Docker Hub中大多镜像都是从这个基础镜像过来的（FROM scratch），然后配置需要的东西。

FROM scratch
ADD centos-7-x86_64-docker.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="20201113" \
    org.opencontainers.image.title="CentOS Base Image" \
    org.opencontainers.image.vendor="CentOS" \
    org.opencontainers.image.licenses="GPL-2.0-only" \
    org.opencontainers.image.created="2020-11-13 00:00:00+00:00"

CMD ["/bin/bash"]

创建一个自己的centos

1、编写Dockerfile文件

[root@lskj dockerfile]# ls
[root@lskj dockerfile]# vim mydockerfile-centos
[root@lskj dockerfile]# cat mydockerfile-centos 
FROM centos
MAINTAINER lskj<2292807998@qq.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH

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

EXPOSE 80


CMD echo $MYPATH
CMD echo "-----end-----"
CMD /bin/bash
[root@lskj dockerfile]#

2、通过这个文件构建镜像

docker build -f dockerfile文件路径 -t 镜像名:[tag]

docker build -f mydockerfile-centos -t mycentos:0.1 .

3、测试运行

docker run -it mycentos:./1

CMD与ENTRYPOINT区别

测试CMD：

[root@lskj dockerfile]# ls
mydockerfile-centos
[root@lskj dockerfile]# vim dockerfile-cmd-test
[root@lskj dockerfile]# cat dockerfile-cmd-test 
FROM centos
CMD ["ls","-a"]
[root@lskj dockerfile]# docker build -f dockerfile-cmd-test -t cmdtest .
Sending build context to Docker daemon  3.072kB
Step 1/2 : FROM centos
 ---> 0d120b6ccaa8
Step 2/2 : CMD ["ls","-a"]
 ---> Running in ab53426fd79f
Removing intermediate container ab53426fd79f
 ---> 066b2d72266f
Successfully built 066b2d72266f
Successfully tagged cmdtest:latest
[root@lskj dockerfile]# docker run 066b2d72266f
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
lost+found
media
mnt
opt
proc
root
run
sbin
srv
sys
tmp
usr
var
[root@lskj dockerfile]#

#想追加一个命令 -l  => ls -al
[root@lskj dockerfile]# docker run 066b2d72266f -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.
ERRO[0000] error waiting for container: context canceled 

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

测试ENTRYPOINT：

[root@lskj dockerfile]# vim dockerfile-entrypoint-test
[root@lskj dockerfile]# cat dockerfile-entrypoint-test 
FROM centos
ENTRYPOINT ["ls","-a"]
[root@lskj dockerfile]# docker build -f dockerfile-entrypoint-test -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 9cbf88848912
Removing intermediate container 9cbf88848912
 ---> bc47f7888c0d
Successfully built bc47f7888c0d
Successfully tagged entrypoint-test:latest

#追加的命令，是直接拼接在ENTRYPOINT命令的后面
[root@lskj dockerfile]# docker run bc47f7888c0d -l
total 56
drwxr-xr-x   1 root root 4096 Nov 25 10:31 .
drwxr-xr-x   1 root root 4096 Nov 25 10:31 ..
-rwxr-xr-x   1 root root    0 Nov 25 10:31 .dockerenv
lrwxrwxrwx   1 root root    7 May 11  2019 bin -> usr/bin
drwxr-xr-x   5 root root  340 Nov 25 10:31 dev
drwxr-xr-x   1 root root 4096 Nov 25 10:31 etc
drwxr-xr-x   2 root root 4096 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 4096 Aug  9 21:40 lost+found
drwxr-xr-x   2 root root 4096 May 11  2019 media
drwxr-xr-x   2 root root 4096 May 11  2019 mnt
drwxr-xr-x   2 root root 4096 May 11  2019 opt
dr-xr-xr-x 110 root root    0 Nov 25 10:31 proc
dr-xr-x---   2 root root 4096 Aug  9 21:40 root
drwxr-xr-x  11 root root 4096 Aug  9 21:40 run
lrwxrwxrwx   1 root root    8 May 11  2019 sbin -> usr/sbin
drwxr-xr-x   2 root root 4096 May 11  2019 srv
dr-xr-xr-x  13 root root    0 Nov 25 02:55 sys
drwxrwxrwt   7 root root 4096 Aug  9 21:40 tmp
drwxr-xr-x  12 root root 4096 Aug  9 21:40 usr
drwxr-xr-x  20 root root 4096 Aug  9 21:40 var
[root@lskj dockerfile]#

Tomcat镜像

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

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

FROM centos
MAINTAINER lskj

COPY readme.txt /usr/local/readme.txt
ADD jdk-8u271-linux-x64.tar.gz /usr/local
ADD apache-tomcat-9.0.35.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.35
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.35
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE 8080

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

3、构建镜像。

docker build -t diytomcat .

4、启动镜像。

5、访问测试。

6、发布项目（由于做了卷挂载，直接在本地编写项目即可）

web.xml

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
  version="4.0" metadata-complete="true">
  ...
</web-app>

发布自己的镜像

DockerHub

1、地址：https://hub.docker.com/，注册自己的账号。

2、确定账号可以登录。

3、登录账号，在自己的服务器上提交自己的镜像。

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

Login Succeeded

4、登录成功后，提交镜像（docker push）

#push自己的镜像到服务器上
docker push diytomcat
#push镜像时，尽量带上版本号
docker push lskj/tomcat:1.0

阿里云镜像服务

1、登录阿里云。

2、找到容器镜像服务。

3、创建命名空间。

4、创建容器镜像。

总结

十、Docker网络

Docker0

清空所有images和容器。

测试

docker是怎样处理容器网络访问的？

[root@lskj /]# docker run -d -P --name tomcat02 tomcat

#查看容器内部的网络地址 ip addr
#容器启动时，会得到一个docker分配的eth0@if69 ip地址
[root@lskj /]# docker exec -it tomcat02 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
68: eth0@if69: <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
[root@lskj /]#

Linux能否ping通容器内部？

[root@lskj /]# 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.079 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.071 ms
64 bytes from 172.17.0.2: icmp_seq=3 ttl=64 time=0.059 ms
#Linux可以ping通docker容器内部

原理

1、每启动一个docker容器，docker就会给docker容器分配一个ip，只要安装了docker，就会有一个网卡docker0。桥接模式，使用的技术是evth-pair。

再次测试ip addr：

2、再启动一个容器，发现又多了一对容器。

这些容器带来的网卡都是一对一对的，evth-pair就是一对的虚拟设备接口，它们都是成对出现的，一段连着协议，一段彼此相连。

正因为这个特性，evth-pair充当一个桥梁，连接各种虚拟网络设备。

OpenStac，Docker容器之间的连接，OVS的连接，都是使用evth-pair技术。

3、测试tomcat02和tomcat03是否可以ping通。

[root@lskj /]# docker exec -it tomcat03 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.100 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.077 ms
#结论：容器和容器之间是可以互相ping通的。

tomcat02和tomcat03是公用的一个路由器，docker0.

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

总结

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

Docker中的所有的网络接口都是虚拟的。虚拟的转发效率高。

只要容器删除，对应网桥一对就没了。

–link容器互联

一个微服务项目，虽然项目不重启，但数据库的ip变化，希望可以通过名字来进行容器访问。

[root@lskj ~]# docker start tomcat01
tomcat01
[root@lskj ~]# docker start tomcat02
tomcat02
[root@lskj ~]# docker exec -it tomcat02 ping tomcat01
ping: tomcat01: Name or service not known

#通过--link可以解决网络连通问题
[root@lskj ~]# docker run -d -P --name tomcat04 --link tomcat02 tomcat
f55fceb8f76bf2eff4e31cff076eb7d94f09a5d3d9405ca2024e00729300c95a

[root@lskj ~]# docker exec -it tomcat04 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.108 ms
...

#反向不可以连通
[root@lskj ~]# docker exec -it tomcat02 ping tomcat04
ping: tomcat04: Name or service not known

查看hosts配置

[root@lskj ~]# docker exec -it tomcat04 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 a9c1a174ab52
172.17.0.4    f55fceb8f76b
[root@lskj ~]#

--link就是在hosts配置中做映射。

现使用Docker不建议使用--link。

自定义网络

查看所有的docker网络

[root@lskj ~]# docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
6c17614d976e        bridge              bridge              local
1b9e71a2742d        host                host                local
fcde1d5b1f3c        none                null                local
[root@lskj ~]#

网络模式

  • bride：桥接 ，docker（默认）

  • none：不配置网络

  • host：和宿主机共享网络

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

测试：

#直接启动的命令 --net 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
#--gateway 192.168.0.1
[root@lskj ~]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
3d1c1fc671b0868404208e873de8efc6539f382e8a9b543ed136f8e362753da4
[root@lskj ~]# docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
6c17614d976e        bridge              bridge              local
1b9e71a2742d        host                host                local
3d1c1fc671b0        mynet               bridge              local
fcde1d5b1f3c        none                null                local
[root@lskj ~]#

自定义的网络就创建完成了。

[root@lskj ~]# docker network inspect mynet
[
    {
        "Name": "mynet",
        "Id": "3d1c1fc671b0868404208e873de8efc6539f382e8a9b543ed136f8e362753da4",
        "Created": "2020-11-26T09:33:07.248648974+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@lskj ~]#

启动两个tomcat进行测试：

[root@lskj ~]# docker run -d -P --name tomcat-net-01 --net mynet tomcat
5a443e156cabadffd64e226fa728a387ad65ab65fba2314e3dd5c20cfd623073
[root@lskj ~]# docker run -d -P --name tomcat-net-02 --net mynet tomcat
0f3909e224c8d8b977979b0a38a5ff1b26106179a18e87f8bde7bb62023a2dd5
[root@lskj ~]# docker network inspect mynet
[
    {
        "Name": "mynet",
        "Id": "3d1c1fc671b0868404208e873de8efc6539f382e8a9b543ed136f8e362753da4",
        "Created": "2020-11-26T09:33:07.248648974+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": {
            "0f3909e224c8d8b977979b0a38a5ff1b26106179a18e87f8bde7bb62023a2dd5": {
                "Name": "tomcat-net-02",
                "EndpointID": "f37105a2d780fe82974e4f198f6dd1f4b5737bfd91f51f47e6c4fb994b759040",
                "MacAddress": "02:42:c0:a8:00:03",
                "IPv4Address": "192.168.0.3/16",
                "IPv6Address": ""
            },
            "5a443e156cabadffd64e226fa728a387ad65ab65fba2314e3dd5c20cfd623073": {
                "Name": "tomcat-net-01",
                "EndpointID": "06c688456f25e0fd883ff4cda9138b38cd505cecd765573a85552c3d946f2279",
                "MacAddress": "02:42:c0:a8:00:02",
                "IPv4Address": "192.168.0.2/16",
                "IPv6Address": ""
            }
        },
        "Options": {},
        "Labels": {}
    }
]
[root@lskj ~]# 

#再次测试ping连接
[root@lskj ~]# 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.101 ms
64 bytes from 192.168.0.3: icmp_seq=2 ttl=64 time=0.082 ms
^C
--- 192.168.0.3 ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 999ms
rtt min/avg/max/mdev = 0.082/0.091/0.101/0.013 ms

#现在不使用--link也可以ping名字了
[root@lskj ~]# 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.067 ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.079 ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=3 ttl=64 time=0.094 ms
^C
--- tomcat-net-02 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 1001ms
rtt min/avg/max/mdev = 0.067/0.080/0.094/0.011 ms
[root@lskj ~]#

自定义的网络，docker自动维护好了对应的关系，推荐平时这样使用网络。

优点

不同的集群使用不同的网络，保证集群是安全和健康的。

网络连通

[root@lskj ~]# docker network --help

Usage:    docker network COMMAND

Manage networks

Commands:
#connect     Connect a container to a network
  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

Run 'docker network COMMAND --help' for more information on a command.

connect

[root@lskj ~]# 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

测试

#测试打通tomcat01 -mynet
[root@lskj ~]# docker network connect mynet tomcat01

[root@lskj ~]# docker network inspect mynet

[root@lskj ~]# 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.088 ms
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=2 ttl=64 time=0.075 ms
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=3 ttl=64 time=0.076 ms
^C
--- tomcat-net-01 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 1001ms
rtt min/avg/max/mdev = 0.075/0.079/0.088/0.011 ms
[root@lskj ~]#

结论

假设要跨网络操作容器，需要使用docker network connect连通。

部署Redis集群

1、创建网卡

docker network create redis --subnet 172.38.0.0/16

2、通过shell脚本创建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

3、启动

docker run -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; \


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; 

docker run -p 6372:6379 -p 16372: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.38.0.12 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf; 

docker run -p 6373:6379 -p 16373: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.38.0.13 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf; 

docker run -p 6374:6379 -p 16374: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.38.0.14 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf;

docker run -p 6375:6379 -p 16375: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.38.0.15 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf;

docker run -p 6376:6379 -p 16376: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.38.0.16 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf;

4、创建集群

[root@lskj /]# docker exec -it redis-1 /bin/sh
/data #

/data # 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


/data # 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
>>> 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.38.0.15:6379 to 172.38.0.11:6379
Adding replica 172.38.0.16:6379 to 172.38.0.12:6379
Adding replica 172.38.0.14:6379 to 172.38.0.13:6379
M: 4562280ea4f7c7e49fcadfc299d0c9912d767988 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
M: d7f953003f939e0a6aec2796635d039acc61a538 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
M: 8cd3da0e9c72dab60380e6ef03dfb66352434ac8 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
S: 2f5df14d3bdb5c340a77cb0a59f564debc8474f8 172.38.0.14:6379
   replicates 8cd3da0e9c72dab60380e6ef03dfb66352434ac8
S: 39422e8958039c54b850539f8bff28b0e424b7f5 172.38.0.15:6379
   replicates 4562280ea4f7c7e49fcadfc299d0c9912d767988
S: f92d88b990e47738ccec9012b5b43d2ad1feae3d 172.38.0.16:6379
   replicates d7f953003f939e0a6aec2796635d039acc61a538
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.38.0.11:6379)
M: 4562280ea4f7c7e49fcadfc299d0c9912d767988 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
S: 2f5df14d3bdb5c340a77cb0a59f564debc8474f8 172.38.0.14:6379
   slots: (0 slots) slave
   replicates 8cd3da0e9c72dab60380e6ef03dfb66352434ac8
S: f92d88b990e47738ccec9012b5b43d2ad1feae3d 172.38.0.16:6379
   slots: (0 slots) slave
   replicates d7f953003f939e0a6aec2796635d039acc61a538
M: d7f953003f939e0a6aec2796635d039acc61a538 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
M: 8cd3da0e9c72dab60380e6ef03dfb66352434ac8 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
S: 39422e8958039c54b850539f8bff28b0e424b7f5 172.38.0.15:6379
   slots: (0 slots) slave
   replicates 4562280ea4f7c7e49fcadfc299d0c9912d767988
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
/data #

十一、SpringBoot微服务打包Docker镜像

1、构建SpringBoot项目。

2、打包应用。

IDEA->右侧边栏Maven->项目名->Lifecycle->package

BUILD SUCCESS，即打包成功。

3、编写Dockerfile。

在打包成功的target目录下创建Dockerfile文件（代码高亮，需安装docker插件）
dockerfile文件内容如下：

FROM java:8

COPY *.jar /app.jar

CMD ["--server.port=8080"]

EXPOSE 8080\

ENTRYPOINT ["java","-jar","/app.jar"]

4、构建镜像。

[root@lskj ~]# cd /home/
[root@lskj home]# ls
docker-test-volume  mysql  test
[root@lskj home]# mkdir idea
[root@lskj home]# cd idea/
[root@lskj idea]# ls
[root@lskj idea]# 

#将打包好的jar包和Dockerfile文件上传至idea目录。
[root@lskj idea]# docker build -t test .

5、发布运行。

[root@lskj idea]# docker run -d --P --name test-springboot test
Docker
赏
  目录