Docker

Docker概述

开发负责项目的开发，运维负责项目的打包部署上线，但是这就存在了问题，就是当项目在不同的环境中是无法直接运行的，还需要控制相关的版本信息还有环境的配置

因此提出了一个想法：在项目打包的时候将环境一起打包，这样就就可以在不同的主机上能正常运行了

项目的打包部署上线的流程：

java — jar（带有环境）---- 打包项目带上环境（镜像） — （docker仓库） — 下载发布的镜像 — 直接运行即可

docker的思想来源于集装箱，docker的核心思想就是打包装箱，箱子之间是相互隔离的，这样不会相互干扰，同时，通过隔离机制，可以将服务器利用到极致

虚拟机：在Windows中装一个 VMware，通过软件我们可以虚拟出来一台或者多台电脑，但是这样很笨重，因此有的时候我们只是想用一下mysql，但是需要给安装整个操作系统然后才能使用

vm：每安装一个系统就需要开启一个虚拟机，很耗费内存

docker：隔离，镜像只需要安装核心的环境即可，不用安装一整个操作系统，非常节省内存，性能高

Docker的作用

虚拟机技术

虚拟机技术缺点：

1.资源占用十分多

2.冗余步骤多

3.启动慢

容器化技术

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

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

传统的虚拟机技术：虚拟一套硬件，运行一个完整的操作系统，然后在这个系统上安装和运行软件 容器内的应用直接运行在宿主机内，容器是没有自己的内核的，也没有虚拟我们的硬件，因此很轻便 每个容器之间是相互隔离的，每个容器内部都有一个属于自己的文件系统，互不影响

DevOps（开发，运维）

应用更快速地交付和部署

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

更快捷升级和扩缩容

使用docker能够快速搭建项目的运行环境，比如将一个项目打包为一个镜像，在要使用的地方就可以使用这个镜像，快速搭建项目的运行环境

更简单的系统运维

在容器之后，我们的开发测试环境都是高度一致的，不会出现在某台电脑上能够运行，在另一台电脑上无法运行的情况

更高效地计算资源利用

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

Docker安装

Docker的基本组成

对上图的解读： Client：就是普通的客户端

Docker_Host：可以理解为docker的服务器，在这里处理客户端的请求

Registry：就是docker的仓库，这个仓库里面有各个版本的镜像文件

上面的过程：就是客户端发起请求，到远程下载镜像，这时候服务端接收到请求，然后从远程仓库中将相应的镜像下载到服务器端，然后将镜像文件放在容器中，然后搭建好环境之后就可以供用户使用

镜像（image）

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

容器（container）

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

启动，停止，删除等基本命令

目前就可以把这个容器理解为是一个简易的linux操作系统

仓库（repository）：

仓库就是用来存放镜像的地方

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

国内的仓库，比如阿里云就有相应的镜像加速工具，可以提高镜像的下载速度

安装Docker

环境准备

1.需要linux基础

2.需要centos 7

3.利用xshell 连接远程服务器操作docker

环境查看

# 系统内核是3.10以上的

[root@lkw /]# uname -r

3.10.0-1127.19.1.el7.x86_64

# 系统版本

[root@lkw /]# cat /etc/os-release

NAME="CentOS Linux"

VERSION="7 (Core)"

ID="centos"

ID_LIKE="rhel fedora"

VERSION_ID="7"

PRETTY_NAME="CentOS Linux 7 (Core)"

ANSI_COLOR="0;31"

CPE_NAME="cpe:/o:centos:centos:7"

HOME_URL="https://www.centos.org/"

BUG_REPORT_URL="https://bugs.centos.org/"

CENTOS_MANTISBT_PROJECT="CentOS-7"

CENTOS_MANTISBT_PROJECT_VERSION="7"

REDHAT_SUPPORT_PRODUCT="centos"

REDHAT_SUPPORT_PRODUCT_VERSION="7"

安装

帮助文档：

1.卸载旧的版本

yum remove docker \

docker-client \

docker-client-latest \

docker-common \

docker-latest \

docker-latest-logrotate \

docker-logrotate \

docker-engine

2.安装需要的一些安装包

yum install -y yum-utils

3.设置镜像的仓库，默认是国外的镜像仓库

# 默认是国外的镜像仓库，下载速度慢

yum-config-manager \

--add-repo \

https://download.docker.com/linux/centos/docker-ce.repo

# 不推荐使用国外的镜像仓库，推荐使用国内的镜像仓库，比如阿里云的镜像仓库

yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

4.安装docker引擎

# 更新域名软件包的索引

yum makecache fast

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

5.启动docker

systemctl start docker

6.使用docker version查看是否安装成功

7.使用docker run命令运行程序

docker run hello-world

8.查看docker拉取的镜像

docker images

拉取的hello-world镜像就在这里

补充：卸载docker

1.卸载依赖

yum remove docker-ce docker-ce-cli containerd.io docker-compose-plugin

2.删除资源

rm -rf /var/lib/docker

rm -rf /var/lib/containerd

阿里云镜像加速

1.登录阿里云，找到容器镜像加速

2.找到镜像加速地址

3.配置使用

sudo mkdir -p /etc/docker

sudo tee /etc/docker/daemon.json <<-'EOF'

{

"registry-mirrors": ["https://h7dbdtwh.mirror.aliyuncs.com"]

}

EOF

sudo systemctl daemon-reload

sudo systemctl restart docker

回顾hello-world运行的流程

docker run的运行流程图：

Docker工作原理

docker是一个C/S架构的系统，docker的守护进程运行在主机上，通过socket从客户端进行访问

dockerServer接收到docker client的请求，就会执行这个指令

docker为什么比vm快

1.docker有着比vm更少的抽象层

2.docker利用的是宿主机的内核，vm使用的是guest os

创建一个新的容器的时候，docker不需要像虚拟机一样重新加载一个操作系统的内核，因为容器是运行在宿主机操作系统的内核之上的

docker的常用命令

帮助命令

docker version # docker的版本信息

docker info # docker的系统信息

docker 命令 --help # 查看docker命令的使用方法

镜像命令

docker images 查看本机的主机上的镜像

[root@lkw /]# docker images

REPOSITORY TAG IMAGE ID CREATED SIZE

hello-world latest feb5d9fea6a5 11 months ago 13.3kB

# 解释

REPOSITORY 镜像的仓库源

TAG 镜像的标签

IMAGE 镜像的id

CREATED 镜像的创建时间

SIZE 镜像的大小

# 可选项

-a --all # 显示所有镜像

-q --quiet # 只显示镜像的id

docker search 搜索镜像

[root@lkw /]# docker search mysql

NAME DESCRIPTION STARS OFFICIAL AUTOMATED

mysql MySQL is a widely used, open-source relation… 13083 [OK]

mariadb MariaDB Server is a high performing open sou… 50

# 可选项，通过过滤来搜索

[root@lkw /]# docker search mysql --filter=STARS=3000

NAME DESCRIPTION STARS OFFICIAL AUTOMATED

mysql MySQL is a widely used, open-source relation… 13083 [OK]

mariadb MariaDB Server is a high performing open sou… 5002 [OK]

[root@lkw /]# docker search mysql --filter=STARS=6000

NAME DESCRIPTION STARS OFFICIAL AUTOMATED

mysql MySQL is a widely used, open-source relation… 13083 [OK]

docker pull 拉取镜像（下载镜像）

# 下载镜像 docker pull 镜像名[:tag]

[root@lkw /]# docker pull mysql

Using default tag: latest 如果没有tag，默认下载的是最新版的latest

latest: Pulling from library/mysql

72a69066d2fe: Pull complete # 分层下载，docker image的核心 联合文件系统

93619dbc5b36: Pull complete

99da31dd6142: Pull complete

626033c43d70: Pull complete

37d5d7efb64e: Pull complete

ac563158d721: Pull complete

d2ba16033dad: Pull complete

688ba7d5c01a: Pull complete

00e060b6d11d: Pull complete

1c04857f594f: Pull complete

4d7cfa90e6ea: Pull complete

e0431212d27d: Pull complete

Digest: sha256:e9027fe4d91c0153429607251656806cc784e914937271037f7738bd5b8e7709 # 签名

Status: Downloaded newer image for mysql:latest

docker.io/library/mysql:latest 真实地址

# 因此docker pull mysql就相当于 docker pull mysql docker.io/library/mysql:latest

# 指定版本进行下载

docker pull mysql:5.7

删除镜像

docker rmi 删除及各项

[root@lkw /]# docker rmi -f c20987f18b13 # 删除指定id的镜像

[root@lkw /]# docker rmi -f 镜像id 镜像id 镜像id # 删除多个镜像，镜像之间空格分隔

[root@lkw /]# docker rmi -f $(docker images -aq) # 删除所有镜像

容器命令

说明：我们有了镜像才可以创建容器，这里下载一个centos镜像测试学习

创建容器并启动

docker run [可选参数] image

# 参数说明

--name="Name" 容器名字，tomcat01，tomcat02用来区分容器

-d 后台方式运行

-it 交互方式运行，进入容器查看内容

-p 指定容器的端口 -p 8080:8080

-p ip：主机端口：容器端口

-p 主机端口：容器端口（常用）

-p 容器端口

-P 随机指定端口

# 测试，启动并进入centos

[root@lkw /]# docker run -it centos /bin/bash

[root@8942deb72973 /]#

[root@8942deb72973 /]# ls # 查看内部的centos，基础镜像很多命令不完善

bin dev etc home lib lib64 lost+found media mnt opt proc root run sbin srv sys tmp usr var

# 退出内部的centos

[root@8942deb72973 /]# exit

exit

[root@lkw /]# ls

bin boot dev etc home lib lib64 lost+found media mnt opt proc root run sbin software springboot srv sys test tmp usr var

列出所有运行的容器

-a：列出当前正在运行的容器+历史运行过的容器

-n=？ 显示最近创建的容器

-q：只显示容器的编号

-aq ：组合使用列出所有容器的编号

[root@lkw /]# docker ps # 列出正在运行的容器

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

[root@lkw /]# docker ps -a # 列出当前正在运行的容器+历史运行过的容器

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

8942deb72973 centos "/bin/bash" 3 minutes ago Exited (0) About a minute ago festive_hellman

09b01c6e9b0b feb5d9fea6a5 "/hello" 3 hours ago Exited (0) 3 hours ago funny_turing

7e6838557a81 feb5d9fea6a5 "/hello" 9 hours ago Exited (0) 9 hours ago epic_boyd

[root@lkw /]# docker ps -a -n=1 # 列出最近一次运行的容器

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

8942deb72973 centos "/bin/bash" 4 minutes ago Exited (0) 2 minutes ago festive_hellman

退出容器

exit # 直接停止容器并退出

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

删除容器

docker rm 容器id 删除指定容器，不能删除正在运行的容器，如果想要删除需要加一个参数-f

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

docker ps -a -q|xargs docker rm # 删除所有的容器

启动和停止容器

docker start 容器id 启动容器

docker restart 重启容器

docker stop 停止容器

docker kill 强制停止当前容器

常用其他命令

后台启动容器

# 命令 docker run -d 镜像名 使用后台运行docker,后台运行就是看不到打印的日志信息，这种运行叫做后台运行

[root@lkw /]# docker run -d centos

b791116968bc8760f0abcbc08a2be8dac332bb65499cd9d0a1f9903bed9dd189

[root@lkw /]#

# 我们发现一个问题就是启动就停止了

# 这是一个常见的坑，因为docker容器使用后台运行的时候，必须要有一个前台进程，docke发现没有应用，就会自动停止

# nginx启动后发现自己没有提供服务就会立刻停止，就会觉得没有程序了

查看日志

docker logs # 查看日志的信息

docker logs -f -t --tail 容器id

# 自己编写一段shell脚本

[root@lkw /]# docker run -d centos /bin/sh -c "while true;do echo lkw;sleep 1;done"

[root@lkw /]# docker ps

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

4bbfd1033080 centos "/bin/sh -c 'while t…" 12 seconds ago Up 12 seconds interesting_feynman

-tf # 显示日志

--tail number # 显示日志的条数

[root@lkw /]# docker logs -tf --tail 10 4bbfd1033080

查看容器中的进程信息

docker top 容器id # 查看容器中正在运行的进程信息

[root@lkw /]# docker top 9998d3910e62

UID PID PPID C STIME TTY TIME CMD

root 5102 5084 0 17:52 pts/0 00:00:00 /bin/bash

[root@lkw /]#

查看镜像的元数据

[root@lkw /]# docker inspect 9998d3910e62

[

{

"Id": "9998d3910e6267954ec6de5ba04c8104b719ef56225e4fb526c3437ed703c3a7",

"Created": "2022-08-28T09:52:39.722640174Z",

"Path": "/bin/bash",

"Args": [],

"State": {

"Status": "running",

"Running": true,

"Paused": false,

"Restarting": false,

"OOMKilled": false,

"Dead": false,

"Pid": 5102,

"ExitCode": 0,

"Error": "",

"StartedAt": "2022-08-28T09:52:40.023476803Z",

"FinishedAt": "0001-01-01T00:00:00Z"

},

"Image": "sha256:5d0da3dc976460b72c77d94c8a1ad043720b0416bfc16c52c45d4847e53fadb6",

"ResolvConfPath": "/var/lib/docker/containers/9998d3910e6267954ec6de5ba04c8104b719ef56225e4fb526c3437ed703c3a7/resolv.conf",

"HostnamePath": "/var/lib/docker/containers/9998d3910e6267954ec6de5ba04c8104b719ef56225e4fb526c3437ed703c3a7/hostname",

"HostsPath": "/var/lib/docker/containers/9998d3910e6267954ec6de5ba04c8104b719ef56225e4fb526c3437ed703c3a7/hosts",

"LogPath": "/var/lib/docker/containers/9998d3910e6267954ec6de5ba04c8104b719ef56225e4fb526c3437ed703c3a7/9998d3910e6267954ec6de5ba04c8104b719ef56225e4fb526c3437ed703c3a7-json.log",

"Name": "/priceless_leavitt",

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

"CgroupnsMode": "host",

"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/553fa672a48a39c9f6b77bfee08e9be35881f0c3d82ec455a059a222e43f2991-init/diff:/var/lib/docker/overlay2/facd1cb4a7832f625b2084dffd5354718c8479cf60cc1188504c5316ca7245e2/diff",

"MergedDir": "/var/lib/docker/overlay2/553fa672a48a39c9f6b77bfee08e9be35881f0c3d82ec455a059a222e43f2991/merged",

"UpperDir": "/var/lib/docker/overlay2/553fa672a48a39c9f6b77bfee08e9be35881f0c3d82ec455a059a222e43f2991/diff",

"WorkDir": "/var/lib/docker/overlay2/553fa672a48a39c9f6b77bfee08e9be35881f0c3d82ec455a059a222e43f2991/work"

},

"Name": "overlay2"

},

"Mounts": [],

"Config": {

"Hostname": "9998d3910e62",

"Domainname": "",

"User": "",

"AttachStdin": true,

"AttachStdout": true,

"AttachStderr": true,

"Tty": true,

"OpenStdin": true,

"StdinOnce": true,

"Env": [

"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"

],

"Cmd": [

"/bin/bash"

],

"Image": "centos",

"Volumes": null,

"WorkingDir": "",

"Entrypoint": null,

"OnBuild": null,

"Labels": {

"org.label-schema.build-date": "20210915",

"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": "391dfe0269fc9a5c44472f53f39da3e373f9ff1c96c2edd2f83aed828214ee8a",

"HairpinMode": false,

"LinkLocalIPv6Address": "",

"LinkLocalIPv6PrefixLen": 0,

"Ports": {},

"SandboxKey": "/var/run/docker/netns/391dfe0269fc",

"SecondaryIPAddresses": null,

"SecondaryIPv6Addresses": null,

"EndpointID": "4008b5e59b7bbf9dcc4bbe3c76e24d9a009d1177079552e39a6b1fcbfb618a81",

"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": "37e44ff8da09c3a0eae6c85b42cdc0235f3d8eb30bc6750ed2fbf102d05b527c",

"EndpointID": "4008b5e59b7bbf9dcc4bbe3c76e24d9a009d1177079552e39a6b1fcbfb618a81",

"Gateway": "172.17.0.1",

"IPAddress": "172.17.0.2",

"IPPrefixLen": 16,

"IPv6Gateway": "",

"GlobalIPv6Address": "",

"GlobalIPv6PrefixLen": 0,

"MacAddress": "02:42:ac:11:00:02",

"DriverOpts": null

}

}

}

}

]

进入当前正在运行的容器

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

# 命令

docker exec -it 容器id bashShell

# 测试---方式一

[root@lkw /]# docker ps

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

9998d3910e62 centos "/bin/bash" 7 minutes ago Up 7 minutes priceless_leavitt

[root@lkw /]# docker exec -it 9998d3910e62 /bin/bash

[root@9998d3910e62 /]# ls

bin dev etc home lib lib64 lost+found media mnt opt proc root run sbin srv sys tmp usr var

[root@9998d3910e62 /]# ps -ef

UID PID PPID C STIME TTY TIME CMD

root 1 0 0 09:52 pts/0 00:00:00 /bin/bash

root 15 0 0 10:01 pts/1 00:00:00 /bin/bash

root 30 15 0 10:01 pts/1 00:00:00 ps -ef

#测试---方式2

# docker attach 容器id

[root@lkw /]# docker attach 9998d3910e62

[root@9998d3910e62 /]# ls

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

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

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

docker cp 容器id：容器内路径 主机上的路径

# 进入centos容器

[root@lkw /]# docker run -it centos /bin/bash

[root@lkw /]# docker attach c189c94f1c04

[root@c189c94f1c04 /]# ls

bin dev etc home lib lib64 lost+found media mnt opt proc root run sbin srv sys tmp usr var

[root@c189c94f1c04 /]# cd home

# 在容器的home目录创建一个test.java文件

[root@c189c94f1c04 home]# touch test.java

[root@lkw /]# docker attach c189c94f1c04

# 退出容器，容器进程关闭，但是容器还在

[root@c189c94f1c04 home]# exit

exit

# 将容器中的文件拷贝到本地的home目录下

[root@lkw /]# docker cp c189c94f1c04:/home/test.java /home

[root@lkw /]# ls

bin boot dev etc home lib lib64 lost+found media mnt opt proc root run sbin software springboot srv sys test tmp usr var

[root@lkw /]# cd home

[root@lkw home]# ls

f2 lkw test.java ysm

小结

作业练习

Docker安装nginx

# 在远程仓库中搜索nginx

[root@lkw home]# docker search nginx

# 安装nginx

[root@lkw home]# docker pull nginx

# 运行nginx，并向外暴露端口号用于访问

[root@lkw home]# docker run -d --name nginx01 -p 2222:80 nginx

# 注意要在阿里云安全组开放相应的端口号

# 在linux中访问nginx，发现成功访问到nginx

[root@lkw home]# curl localhost:2222

启动nginx并向外暴露端口的原理：

同时在物理机也可以访问这个开启的nginx，因为端口linux的端口也被暴露给了外网，而docker容器中的nginx暴露给了linux，间接地，容器内部地nginx也暴露给了外网

对上面的过程进行解释：上面是在linux服务器上通过docker技术安装了一个容器，在容器的内部安装了nginx，但是因为容器之间以及容器和linux系统之间是隔离的，这个容器也是一个小型的服务器，里面也有防火墙，因此要想它的外一层，也就是linux系统能够访问它，就需要将它的端口暴露给linux系统，然后因为我们如果想要在外网也就是物理主机上访问服务器（linux）上的资源，也需要打开防火墙的相应端口，并且我们使用的是阿里云的服务器，所以需要在阿里云的安全组上配置相应的端口信息，这样外网才可以成功访问服务器，然后服务器又可以访问其内部容器的nginx，间接的外网也就可以访问服务器内部的nginx服务

作业2 docker安装tomcat

# 安装tomcat

docker pull tomcat

# 启动并运行tomcat

docker run -d -p 3333:8080 --name tomcat01 tomcat

# 启动tomcat之后并且已经在阿里云的安全组开启相关的端口号了但是依然无法访问，这是因为阿里云镜像的原因，因为阿里云默认下载的是最小的镜像，所有其他不必要的东西都剔除掉了

# 进入容器

docker exec -it tomcat01 /bin/bash

# 将tomcat目录下的webapps.dist目录下的所有内容复制到webapps，因为在访问Tomcat的时候，静态资源都放在该目录下

cp -r webapps.dist/* webapps/

# 这个时候刷新网页发现可以访问到tomcat的首页面

可视化

portainer（docker的图形化管理工具，可以提供一个后台面板供我们操作）

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

管理面板首页

Docker镜像

什么是镜像

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

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

如何得到镜像

从远程仓库下载从别的地方拷贝自己制作一个镜像

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就是各种不同的操作系统发行版，比如Ubantu，centos等

平时我们安装的虚拟机中的centos都要几个G，但是在docker里面安装的centos才几百MB

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

分层理解

分层的镜像

我们下载一个redis，观察日志输出

我们发现，docker的镜像下载是一层一层进行的

最大的好处就是资源共享了，比如有多个镜像从相同的Base镜像构建而来，那么宿主机只需在磁盘上保留一份base镜像，同时内存中也需要加载一份base镜像，这样就可以为所有容器服务了，而镜像每一层都可以被共享

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

[root@lkw /]# docker image inspect redis:latest

[

{

"Id": "sha256:7614ae9453d1d87e740a2056257a6de7135c84037c367e1fffa92ae922784631",

"RepoTags": [

"redis:latest"

],

"RepoDigests": [

"redis@sha256:db485f2e245b5b3329fdc7eff4eb00f913e09d8feb9ca720788059fdc2ed8339"

],

"Parent": "",

"Comment": "",

"Created": "2021-12-21T12:42:49.755107412Z",

"Container": "13d25f53410417c5220c8dfe8bd49f06abdbcd69faa62a9b877de02464bb04a3",

"ContainerConfig": {

"Hostname": "13d25f534104",

"Domainname": "",

"User": "",

"AttachStdin": false,

"AttachStdout": false,

"AttachStderr": false,

"ExposedPorts": {

"6379/tcp": {}

},

"Tty": false,

"OpenStdin": false,

"StdinOnce": false,

"Env": [

"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",

"GOSU_VERSION=1.12",

"REDIS_VERSION=6.2.6",

"REDIS_DOWNLOAD_URL=http://download.redis.io/releases/redis-6.2.6.tar.gz",

"REDIS_DOWNLOAD_SHA=5b2b8b7a50111ef395bf1c1d5be11e6e167ac018125055daa8b5c2317ae131ab"

],

"Cmd": [

"/bin/sh",

"-c",

"#(nop) ",

"CMD [\"redis-server\"]"

],

"Image": "sha256:e093f59d716c95cfce82c676f099b960cc700432ab531388fcedf79932fc81ec",

"Volumes": {

"/data": {}

},

"WorkingDir": "/data",

"Entrypoint": [

"docker-entrypoint.sh"

],

"OnBuild": null,

"Labels": {}

},

"DockerVersion": "20.10.7",

"Author": "",

"Config": {

"Hostname": "",

"Domainname": "",

"User": "",

"AttachStdin": false,

"AttachStdout": false,

"AttachStderr": false,

"ExposedPorts": {

"6379/tcp": {}

},

"Tty": false,

"OpenStdin": false,

"StdinOnce": false,

"Env": [

"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",

"GOSU_VERSION=1.12",

"REDIS_VERSION=6.2.6",

"REDIS_DOWNLOAD_URL=http://download.redis.io/releases/redis-6.2.6.tar.gz",

"REDIS_DOWNLOAD_SHA=5b2b8b7a50111ef395bf1c1d5be11e6e167ac018125055daa8b5c2317ae131ab"

],

"Cmd": [

"redis-server"

],

"Image": "sha256:e093f59d716c95cfce82c676f099b960cc700432ab531388fcedf79932fc81ec",

"Volumes": {

"/data": {}

},

"WorkingDir": "/data",

"Entrypoint": [

"docker-entrypoint.sh"

],

"OnBuild": null,

"Labels": null

},

"Architecture": "amd64",

"Os": "linux",

"Size": 112691373,

"VirtualSize": 112691373,

"GraphDriver": {

"Data": {

"LowerDir": "/var/lib/docker/overlay2/c85fe59b57337039f0cd3966786bf902967ba98bbdfa5c7cc2bd6077b4ff7d65/diff:/var/lib/docker/overlay2/62d28a4c0fc8eb939b1318f2e8e39593d8e2fd49c1e2845a4acdf04d4632593a/diff:/var/lib/docker/overlay2/6d5fd3243aa023a4458c6cfff9e0adf0d3e16a8d9bbe4f8fa10610743dbc6040/diff:/var/lib/docker/overlay2/65a8f60c903e97a0893fc5c5aca858b6f32c2cb09e08377a22c0bc1c22311afe/diff:/var/lib/docker/overlay2/d579b83b32a0fd9a25f5f524300ff402642a0d7099e01ca5f9de945343315bf4/diff",

"MergedDir": "/var/lib/docker/overlay2/01228ac22a359e568bb00f52f711ea96a66cbdd3486db008c48bc755d3cbd6e0/merged",

"UpperDir": "/var/lib/docker/overlay2/01228ac22a359e568bb00f52f711ea96a66cbdd3486db008c48bc755d3cbd6e0/diff",

"WorkDir": "/var/lib/docker/overlay2/01228ac22a359e568bb00f52f711ea96a66cbdd3486db008c48bc755d3cbd6e0/work"

},

"Name": "overlay2"

},

"RootFS": {

"Type": "layers",

"Layers": [

"sha256:2edcec3590a4ec7f40cf0743c15d78fb39d8326bc029073b41ef9727da6c851f",

"sha256:9b24afeb7c2f21e50a686ead025823cd2c6e9730c013ca77ad5f115c079b57cb",

"sha256:4b8e2801e0f956a4220c32e2c8b0a590e6f9bd2420ec65453685246b82766ea1",

"sha256:529cdb636f61e95ab91a62a51526a84fd7314d6aab0d414040796150b4522372",

"sha256:9975392591f2777d6bf4d9919ad1b2c9afa12f9a9b4d260f45025ec3cc9b18ed",

"sha256:8e5669d8329116b8444b9bbb1663dda568ede12d3dbcce950199b582f6e94952"

]

},

"Metadata": {

"LastTagTime": "0001-01-01T00:00:00Z"

}

}

]

理解：

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

举一个简单的例子，例如基于Ubantu Linux16.04创建一个新的镜像，这就是新镜像的第一层，如果在该镜像中添加Python包，就会在基础镜像层之上创建第二个镜像层，如果继续添加一个安全补丁，则会创建第三个镜像层

在添加额外的镜像层的同时，镜像始终保持当前所有镜像的组合，下面有一个简单的例子，每个镜像层包含3个文件，而整个镜像包含了来自两个镜像层的6个文件

下图中展示了一个稍微复杂的三层镜像，在外部看来整个镜像只有6个文件，这是因为最上层的文件7是文件5的更新版本

这种情况下，上层镜像层中的文件覆盖了底层镜像层中的文件，这样就是的文件的更新版本作为一个新镜像层添加到镜像当中，docker通过存储引擎（新版本采用快照机制）的方式来实现镜像层对外展示为统一的文件系统

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

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

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

特点

docker镜像都是只读的，当容器启动的时候，一个新的可写层被加到镜像的顶部，这一层即使容器层，容器层之下的都是镜像层

commit镜像

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

# 命令和git类似

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

# 1.启动一个默认的tomcat

# docker run -it -p 8080:8080 tomcat

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

# 3.将webapps.dist目录下的文件全部拷贝到webapps下面这个时候在访问tomcat的时候就能访问到tomcat的首页

# 4.因为每次在启动容器的时候原来拷贝到webapps下面的文件都没有了，需要重新拷贝，这样操作很麻烦，因此可以将已经拷贝好的这个状态保存好，下次再启动的时候可以使用保存好的这个状态，就不用再重新拷贝文件夹下面的内容了

如果想要保存当前的状态，就可以通过commit来提交，并获得一个新的镜像，就好比vmware里面的快照一样

容器数据卷

如果数据都在容器中的话，那么当容器删除的时候，那么容器中保存的数据就会丢失

容器之间需要一个数据共享的技术，就是docker容器内部产生的数据可以自动同步到本地

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

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

使用数据卷

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

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

docker run -it -v /home/ceshi:/home centos /bin/bash # 挂载

docker inspect 容器id 可以查看容器的挂载信息

测试挂载，分别在容器外部和容器内部创建文件，查看挂载情况

测试：先停止容器，然后在主机上修改修改文件的内容，然后再启动容器，然后我们会发现之后数据会被同步到主机上

以后修改只需要在服务器上进行修改即可，容器内会自动同步，不用进入容器进行修改

安装MySQL

MySQL的数据持久化问题 data目录

# 获取镜像

docker pull mysql:5.7

# 运行容器，需要做数据挂载，但是安装启动mysql的时候需要设置初始密码

# 官方测试 docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

# 启动mysql并修改初始密码

-d 后台运行

-p 端口映射

-v 卷挂载

-e 环境配置

--name 容器名字

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

# 启动成功之后，在本地创建连接测试一下

# 在本地创建一个数据库，然后在远程主机上查看数据库的数据也发生了改变

# 在本地将整个MySQL删除，然后再进入mysql的的data目录下，发现mysql的数据还在

假设我们将容器删除，发现我们挂载到本地的数据卷依然还在，这就实现了数据的持久化操作

具名挂载和匿名挂载

匿名挂载

# 匿名挂载

-v 容器内路径

docker run -d -p --name nginx01 -v /etc/nginx nginx

# 查看所有的volume挂载情况

docker volume ls

上面的就是匿名挂载，因为volume的名字是一个哈希值，不是具体可以识别的名字

具名挂载

# 具名挂载

docker run -d -P --name nginx03 -v juming-nginx:/etc/nginx nginx

# 查看卷路径

docker volume inspect juming-nginx

查看卷的路径信息

总结：所有的docker容器内的卷，没有指定目录的情况下默认是在/var/lib/docker/volume/卷名/_data

通过具名挂载可以方便我们找到我们的卷，大多数情况下我们使用具名挂载

# 如何确定是具名挂载还是匿名挂载，还是指定路径挂载

-v 容器内路径 # 匿名挂载

-v 卷名：容器内路径 # 具名挂载

-v /容宿主机路径：容器内路径 # 容器内路径挂载

拓展：

# 通过 -v 容器内路径：ro rw修改读写权限

# 一旦设置了容器权限，容器对我们挂载出来的内容就有限制了

docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:ro nginx # 设置卷的只读权限

docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:rw nginx

# 这里的ro指的是这个路径只能通过宿主机来操作，容器的内部无法操作

初识DockerFile

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

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

方式二：

# 创建一个dockerfile文件，名字可以随机，建议使用dockerfile

# 文件中的指令和参数

FROM centos

VOLUME ["volume01","volume02"]

CMD echo "======end======"

CMD /bin/bash

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

启动自己写的容器

说明肯定在这个卷的外部有一个同步的目录

先进入其中的一个目录，比如在volume01中新建一个test.txt

然后使用docker inspect 容器id命令查看挂载的卷，然后复制这卷的地址，然后进入到卷中，我们发现在这个卷中也新建了一个叫做test.txt的文件

这种方式未来使用的很多，假设构建镜像的时候没有挂载卷，要手动进行挂载 -v 卷名：容器内路径

数据卷容器

两个mysql同步数据

启动三个容器

可以删除docker01，查看一下docker02和docker03是否还可以访问这个文件，测试的结果是仍然可以正常访问

容器和容器之间是相互拷贝的原理，并不是说容器被删除了数据就会丢失，而是只要有一个容器还存在，那么一个容器的删除不会导致数据丢失

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

，一旦持久化到了本地数据就不会被删除了

DockerFile

dockerfile 是用来构建docker镜像的文件，就是一个命令参数脚本

构建步骤：

1.编写一个dockerfile文件

2.docker build 构建成为一个镜像

3.docker run 运行镜像

4.docker push发布镜像（Docker Hub ，阿里云镜像仓库）

​

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

DockerFile的构建过程

基础知识：

1.每个保留关键字都是大写的

2.执行命令的顺序是从上到下的

3.# 表示注释

4.每一个指令都会创建提交一个新的镜像层，并提交

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

docker镜像逐渐成为企业交付的标准

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

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

docker容器：容器就是镜像运行起来的提供服务的

dockerfile的指令

FROM 基础镜像 centos，ubantu 一切从这里开始构建

MAINTAINER # 镜像是谁写的，姓名+邮箱

RUN # docker镜像构建的时候需要运行的命令

ADD # 步骤：搭建一个tomcat镜像，tomcat的压缩包就是我们要加进去的，添加内容

WORKDIR # 镜像的工作目录

VOLUME # 容器卷，要挂载的目录

EXPOSE # 指定暴露端口

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

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

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

COPY # 类似于ADD，将我们的文件拷贝到镜像当中

ENV # 构建的时候设置环境变量

实战测试

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

创建一个自己的centos

# 编写dockerfile的文件

FROM centos:7

MAINTAINER lkw<2645536992@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

# 2.通过文件构建镜像

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

# 3.运行images文件

docker run -it mycentos:1.0

# 4.通过vim工具可以创建文件，通过cat命令查看文件

[root@91b4b668cdd8 local]# vim test

[root@91b4b668cdd8 local]# cat test

hello mydockerfile

CMD和ENTRYPOINT的区别

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

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

测试cmd命令

[root@lkw dockerfile]# cat docker-cmd-test

FROM centos

CMD ["ls","-a"]

[root@lkw dockerfile]# docker build -f docker-cmd-test -t cmdtest . # 构建镜像

[root@lkw dockerfile]# docker run 1c1e0be0a858 # 运行镜像，列出了所有的目录

.

..

.dockerenv

bin

dev

etc

home

lib

lib64

lost+found

media

mnt

opt

proc

root

run

sbin

srv

sys

tmp

usr

var

# 如果追加一个命令的话

[root@lkw dockerfile]# docker run 1c1e0be0a858 -l

docker: Error response from daemon: failed to create shim task: OCI runtime create failed: runc create failed: unable to start container process: exec: "-l": executable file not found in $PATH: unknown.

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

测试ENTRYPOINT

[root@lkw dockerfile]# cat docker-cmd-entrypoint

FROM centos

ENTRYPOINT ["ls","-a"]

[root@lkw dockerfile]# docker build -f docker-cmd-entrypoint -t entrypoint-test .

[root@lkw dockerfile]# docker run 79a6c18c7075

.

..

.dockerenv

bin

dev

etc

home

lib

lib64

lost+found

media

mnt

opt

proc

root

run

sbin

srv

sys

tmp

usr

var

# entrypoint在启动docker的时候直接追加在cmd命令后面的

[root@lkw dockerfile]# docker run 79a6c18c7075 -l

total 56

drwxr-xr-x 1 root root 4096 Aug 31 02:09 .

drwxr-xr-x 1 root root 4096 Aug 31 02:09 ..

-rwxr-xr-x 1 root root 0 Aug 31 02:09 .dockerenv

lrwxrwxrwx 1 root root 7 Nov 3 2020 bin -> usr/bin

drwxr-xr-x 5 root root 340 Aug 31 02:09 dev

drwxr-xr-x 1 root root 4096 Aug 31 02:09 etc

drwxr-xr-x 2 root root 4096 Nov 3 2020 home

lrwxrwxrwx 1 root root 7 Nov 3 2020 lib -> usr/lib

lrwxrwxrwx 1 root root 9 Nov 3 2020 lib64 -> usr/lib64

drwx------ 2 root root 4096 Sep 15 2021 lost+found

drwxr-xr-x 2 root root 4096 Nov 3 2020 media

drwxr-xr-x 2 root root 4096 Nov 3 2020 mnt

drwxr-xr-x 2 root root 4096 Nov 3 2020 opt

dr-xr-xr-x 93 root root 0 Aug 31 02:09 proc

dr-xr-x--- 2 root root 4096 Sep 15 2021 root

drwxr-xr-x 11 root root 4096 Sep 15 2021 run

lrwxrwxrwx 1 root root 8 Nov 3 2020 sbin -> usr/sbin

drwxr-xr-x 2 root root 4096 Nov 3 2020 srv

dr-xr-xr-x 13 root root 0 Aug 29 10:13 sys

drwxrwxrwt 7 root root 4096 Sep 15 2021 tmp

drwxr-xr-x 12 root root 4096 Sep 15 2021 usr

drwxr-xr-x 20 root root 4096 Sep 15 2021 var

DockerFile中有很多命令是相似的，需要对比学习

实战：Tomcat镜像

1.准备镜像文件，准备一个tomcat的压缩包，jdk压缩包（tomcat的运行环境）

2.编写dockerfile文件，官方命名Dockerfile，在build的时候会自动去寻找这个文件，不用使用-f参数指定文件

FROM centos:7

MAINTAINER lkw<2645536992@qq.com>

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

ADD jdk-8u341-linux-x64.tar.gz /usr/local/

ADD apache-tomcat-9.0.65.tar.gz /usr/local/

RUN yum -y install vim

ENV MYPATH /usr/local

WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_341

ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.65

ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.65

ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/bin:$CATALINA_HOME/lib

EXPOSE 8080

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

3.构建镜像

docker build -t diytomcat

4.启动镜像

5.访问测试

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

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"

version="5.0">

<%@ page contentType="text/html;charset=UTF-8" language="java" %>

Hello JSP!!!

发现部署项目成功，直接访问就可以

掌握Dockerfile的编写，以后一律使用docker镜像来发布运行

将镜像发布到Docker Hub

1.先注册账号

2.确保账号可用

3.在本地服务器使用docker -login -u 用户名 -p 密码 登录

4.将自己创建好的镜像发布到远程仓库中

# 在发布镜像之前想要使用tag命令打一个tag

将镜像发布到阿里云的镜像仓库

1.登录阿里云

2.找到容器镜像服务

3.创建命名空间

4.创建容器镜像

5.浏览阿里云

在阿里云查看上传的镜像

Docker用法小结

好文链接

 您阅读本篇文章共花了：