学习视频链接：B站 遇见狂神说
一、概述
Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的镜像中，然后发布到任何流行的 Linux或Windows 机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口。
docker是基于Go语言开发的。
官网：https://www.docker.com/
文档地址：https://docs.docker.com/
仓库地址：https://hub.docker.com/
容器化技术
容器技术:有效的将单个操作系统的资源划分到孤立的组中，以便更好的在孤立的组之间平衡有冲突的资源使用需求，这种技术就是容器技术。
容器化技术不是模拟一个完整的操作系统。
Docker与虚拟机技术的区别：
- 传统虚拟机，虚拟出一套硬件，运行一个完整的操作系统，然后在这个系统上安装和运行软件。
- 容器内的应用直接运行在宿主机的内核中，容器是没有自己的内核的，也没有虚拟的硬件，故轻便。
- 每个容器间是互相隔离的，每个容器内都有一个属于自己的文件系统，互不影响。
DevOps（开发、运维）
应用更快速的交互和部署。
Docker，打包镜像，发布测试，一键运行。
更便捷的升级和扩容。
更简单的系统运维。
更高效的计算资源利用。
Docker是内核级别的虚拟化，可以在一个物理机上运行很多容器实例。服务器的性能可以被压榨到极致。
二、安装
Docker的基本组成
镜像（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
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
docker search
搜索镜像
[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
扫一扫
261
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
