【开发技术】2万字详细介绍Docker 和 web项目的部署监控，docker部署，拉取kafana，prometheus镜像监控
SpringBoot
内容管理
-
- Linux Redis Connnect
-
- 设置服务器redis开机自启动
- 修改Redis配置文件
- 关闭防火墙
- 关闭selinux
- 连接Redis
- Docker
-
- Docker安装
-
- 基础环境配置【配置源】
- 网卡配置发放【内核流量转发】
- yum快速安装
- 镜像加速器【配置ustc的加速器】
- Docker生命周期
- 镜像images原理
-
- 在虚拟机上灵活替换不同的Linux发行版【相关发行版镜像】
- docker镜像解决问题【迁移，不依赖】
- images分层原理
- docker镜像【每一个镜像都包含完整的层，至少包含base】
- Docker快速使用【nginx运行
- Docker镜像管理常用命令
-
- docker search XXX 在regisry镜像站中搜索XXX镜像
- docker pull XXX (:tag)
- docker images （image ls）【-q】 【名称 + tag】 查看本地镜像
- docker rmi [docker ID前三位就可] 删除本地ID为XX的镜像【不依赖记录rm】
- docker image save XXX > XXX.tgz 导出镜像为压缩包，指定路径
- docker image load -i XXXX.tgz 从指定路径下导入镜像
- docker image inspect 镜像ID 显示镜像的详细信息
- Docker容器管理命令
-
- docker run 【参数 -p -v -d -i t --rm】 镜像名称/ID 【bash等】 运行镜像生成容器(还可进入容器)
- docker logs 【-f】 容器ID 查看容器日志
- docker container inspect 容器ID 查看容器详细信息
- docker exec -it 容器ID bash 进入容器内的发行版终端
- exit （容器内执行） 退出容器
- docker ps 【-a】 查看本地容器运行情况
- docker port 容器ID 查看容器的端口转发情况
- docker commit 容器ID diy的镜像名 将容器提交为镜像放到本地镜像库
- docker rm 镜像ID 删除镜像记录
- docker stop 容器ID 停止容器的运行
- docker start 容器ID 开启容器的运行【stop的】
- docker restart 容器ID 重启容器yunx
- docker version 查看docker的版本
- docker info 查看docker的基本信息【存储镜像位置...】
- docker build Dockerfile文件位置
- docker tag 容器ID 自定义容器Name
- dockerfile 常用指令
-
- FROM 指定base image【不一定从发行版开始构建，可以直接在任何镜像】
- MAINTAINER 指定维护者信息【可以没有】
- RUN 构建镜像时执行的...命令
- ADD 复制宿主机文件进入容器内， 会自动解压
- COPY 复制...和ADD一样
- WORKDIR 设置当前工作目录【类似cd的作用】
- USER 改变环境，切换用户
- VOLUME 设置卷，挂载主机目录【目录映射】
- EXPOSE 打开门，指定对外的端口，暴露端口
- ENV 【ARG】 设置容器的环境变量
- CMD 指定容器启动后需要执行的事情
- ENTRYPOINT【传入的只是当作参数，而CMD形式为覆盖】
- Dockerfile快速实践
- 容器内运行程序 docker只是进程
- Boot项目发布部署
-
- 多环境配置 spring Profile
- springBoot内置Tomcat ---- 打包为可执行jar文件
- 基于传统的web容器 ---- 打包为war可执行文件
- 现代化发布 ---- 基于Docker发布
- 现代化发布 ---- 基于RPM发布
- 运行监控
-
- 使用Spring Boot Actuator 查看运行指标
- Prometheus --- 系统监控警报工具 docker拉取
- Grafana ----- 可视化监控【补充Prometheus 强大UI】
- Spring Boot devtools
-
- 自动配置【devtools自动】
- 热部署
- LiveReload 插件支持静态资源的更新
- 全局配置
- 远程应用
SpringBoot开发技术 — 现代化部署与运维、docker、运行监控，Grafana
技术无止境… 简单的测试部分主要就是@SpringBootTest，接下来就是介绍部署运维了，简单介绍Docker容器和基于docker的发布部署
程序编写了完备的测试用例之后，软件开发生命周期到达最终阶段— 部署运维；随着开发和项目交付模式的改变，现代的开发讲究高效敏捷，方便快捷部署并且稳定运行十分重要 【依赖项的变化之类】
Linux Redis Connnect
设置服务器redis开机自启动
每次手动开启redis服务不是很方便，设置开机自启动就是交给Systemctl管理，主要就是编写service文件，mysql也是，编写其中的ExecStart
还是和mysql的目录一级创建service， touch /usr/lib/systemd/system/redis.service
[root@localhost system]# touch redis.service
[root@localhost system]# vim redis.service
[root@localhost system]# cat redis.service
[Unit]
Description=The redis-server Process Manager
After=syslog.target network.target
[Service]
Type=simple
PIDFile=/var/run/redis_6379.pid
ExecStart=/usr/local/redis-6.2.6/src/redis-server /usr/local/redis-6.2.6/redis.conf
ExecReload=/bin/kill -USR2 $MAINPID
ExecStop=/bin/kill -SIGINT $MAINPID
[Install]
WantedBy=multi-user.target
这样就可以使用systemctl管理redis服务
systemctl enable redis
之前数据库直接使用的Windows Redis，但是实际场景中使用的是Linux版本，这里要进行远程连接，需要进行相关的配置
修改Redis配置文件
cd usr/local/redis.XXX
vim redis.conf
- 修改bind127.0.0.0 为 bind 0.0.0.0 ----> 允许所有IP访问
- 修改daemonize 为yes —> 允许后台运行redis
- 修改protected-mode 为no ----> 关闭保护模式
启动redis server使用修改过的配置文件
./redis-server ../redis.conf
如果不是 redis.conf，那么需要 ./redis-server …/redisXXX.conf
启动后，可以通过 ps -ef|grep redis查看进程
[root@localhost ~]# ps -ef|grep redis
root 4555 4404 0 10:55 pts/0 00:00:00 ./redis-server *:6379
可以看到端口从127.0.0.0.redis变为了*.redis，允许多ip访问
关闭防火墙
要访问redis，需要关闭虚拟机防火墙，docker下载也需要关闭
systemctl stop firewalld
关闭selinux
SELinux时安全增强Linux，内核模块，安全子系统，最大限度减少系统中服务进行可访问的资源
而有的软件对于SELinux的安全规则支持不够好，所以就建议把selinux关闭
三种状态：
- enforceing： 强制模式，运行安全规则
- permissive： 宽容模式，警告但是不会限制
- disabled： 永久关闭，没有运行
查看状态：
getenforce
临时关闭：
setenforce 0 就是变为宽容模式permissive
永久关闭
//进入配置文件中修改
cd /etc/selinux
vim conf
将其状态 变为disabled，然后重启机器
docker安装时状态getenforce 为disabled
连接Redis
上面已经按照自定义配置运行server，可以进行远程访问，【可以多测试几次，i之前卡住了】，在项目中配置application-dev.yml
redis:
port: 6379
host: 192.XX8.XX4.100 #连接远程redis
database: 1
timeout: 1000
password:
jedis:
pool:
max-active: 10
max-idle: 8
min-idle: 1
max-wait: 1
这里为了快速连接没有设置密码，直接连接
/**
* 测试远程连接redis
*/
@Test
public void testJedis_WithRemoteServer() {
redisCache.set("xiaohuan","isPig");
System.out.println(redisCache.get("time"));
}
//连接成功Success！
we 还可以进入配置文件修改log file
而iptables的规则之前全部都清理掉了【iptables -F】这里不需要设置
yum install iptables-services //最新的服务
systemctl enable iptables //开机自启动
systemctl restart iptables //重启
Docker
Docker是平台即服务的产品PaaS，使用操作系统级别的虚拟的容器化技术帮助实现软件服务以互相隔离的方式进行，三个基本概念： Dockerfile，镜像，容器； Docker其实就是一个虚拟化容器
Docker和redis类似，主要是在Linux系统上面使用，可以直接安装Docker提供的docker for Windows【必须为64位并且需要启动Hyper-V操作】硬件虚拟化操作
直接进入Windows系统的 【启用或关闭Windows功能】，选择hyper-v即可，但是普通的家庭版Windows没有，自己选择
家庭版没有可以写脚本运行，插入电脑，但是为了安全，所以还是在centOs7上面安装
Docker的安装采用： 虚拟化 + 容器： Infrastructure可能笔记本或者服务器，GuestOs就是安装的虚拟机比如CentOs，虚拟机上面再安装Docker
Docker安装
基础环境配置【配置源】
- 要安装Docker，首先就是要将虚拟机配置一下，配置之后要关闭防火墙
[root@localhost ~]# systemctl disable firewalld
Removed symlink /etc/systemd/system/multi-user.target.wants/firewalld.service.
Removed symlink /etc/systemd/system/dbus-org.fedoraproject.FirewallD1.service.
- 之后就是设置yum源，Docker源为国外，为了更快，所以需要配置国内的镜像
在XShell中复制为CTRL + INSERT ,粘贴为SHIFT + INSERT
除了yum源之外，还有epel额外源
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
执行之后：
[root@localhost ~]# wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
--2022-07-28 18:23:32-- http://mirrors.aliyun.com/repo/Centos-7.repo
正在解析主机 mirrors.aliyun.com (mirrors.aliyun.com)... 113.141.190.102, 113.141.190.103, 113.141.190.105, ...
正在连接 mirrors.aliyun.com (mirrors.aliyun.com)|113.141.190.102|:80... 已连接。
已发出 HTTP 请求，正在等待回应... 200 OK
长度：2523 (2.5K) [application/octet-stream]
正在保存至: “/etc/yum.repos.d/CentOS-Base.repo”
100%[=======================================================================================================================================================================>] 2,523 --.-K/s 用时 0s
2022-07-28 18:23:32 (5.07 MB/s) - 已保存 “/etc/yum.repos.d/CentOS-Base.repo” [2523/2523])
[root@localhost ~]# wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
--2022-07-28 18:23:53-- http://mirrors.aliyun.com/repo/epel-7.repo
正在解析主机 mirrors.aliyun.com (mirrors.aliyun.com)... 113.141.190.100, 113.141.190.105, 113.141.190.104, ...
正在连接 mirrors.aliyun.com (mirrors.aliyun.com)|113.141.190.100|:80... 已连接。
已发出 HTTP 请求，正在等待回应... 200 OK
长度：664 [application/octet-stream]
正在保存至: “/etc/yum.repos.d/epel.repo”
100%[=======================================================================================================================================================================>] 664 --.-K/s 用时 0s
2022-07-28 18:23:53 (99.3 MB/s) - 已保存 “/etc/yum.repos.d/epel.repo” [664/664])
- 清理缓存和生成新的缓存
yum clean all
yum makecache
- 清空防火墙规则 ： iptables -F
- 查看SElinux状态： getenforce
- 关闭防火墙： systemctl stop firewalld
网卡配置发放【内核流量转发】
docker必须安装在CentOS7 、 内核版本不低于3.10才可以， uname -r 查看虚拟机版本
要想Docker支持，所以必须开启linux内核的流量转发
所以就是创建docker.conf文件写入相关的网络配置【cat重定向】
cat <<EOF> /etc/sysctl.d/docker.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.conf.default.rp_filter = 0
net.ipv4.conf.all.rp_filter = 0
net.ipv4.ip_forward = 1
EOF
执行完毕后，ls就可以看到文件创建成功
- 要想写入内核的配置文件生效，必须加载参数
sysctl -p /etc/sysctl.d/docker.conf
这里执行完毕如果出现错误： sysctl: cannot stat /proc/sys/net/bridge/bridge-nf-call-ip6tables: 没有那个文件或目录
sysctl: cannot stat /proc/sys/net/bridge/bridge-nf-call-iptables: 没有那个文件或目录
那么就先执行
modprobe br_netfilter
添加目录之后再执行上面的加载操作
yum快速安装
首先需要配置好yum仓库
配置阿里云自带的仓库： 安装docker
- 查看当前源中的可用的版本
yum list docker-ce --showduplicates | sort -r
如果直接查询，因为当前没有docker-ce，会报错： 错误：没有匹配的软件包可以列出
已加载插件：fastestmirror, langpacks
- 配置阿里云提供的docker专属的repo仓库
curl -o /etc/yum.repos.d/docker-ce.repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
curl -o /etc/yum.repos.d/CentOS-7.repo http://mirrors.aliyun.com/repo/Centos-7.repo
之后执行yum clean all && yum makecache 更新缓存
[root@localhost ~]# curl -o /etc/yum.repos.d/docker-ce.repo http://mirrors.aliyun.com/cocker-ce/linux/centos/docker-ce.repo
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 2318 100 2318 0 0 10580 0 --:--:-- --:--:-- --:--:-- 10633
[root@localhost ~]# curl -o /etc/yum.repos.d/CentOS-7.repo http://mirrors.aliyun.com/repo/Centos-7.repo
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 2523 100 2523 0 0 40723 0 --:--:-- --:--:-- --:--:-- 47603
[root@localhost ~]# yum clean all && yum makecache
已加载插件：fastestmirror, langpacks
Repository base is listed more than once in the configuration
Repository updates is listed more than
- 查看镜像源中可用版本
yum list docker-ce --showduplicates | sort -r
出现问题： File contains no section headers.
file: file:///etc/yum.repos.d/docker-ce.repo, line: 1
‘\n’ 说明yum docker-ce源没有配置，可以删除原文件重新下载 【这里的错误就是i 的写错了】
rm -f /etc/yum.repos.d/docker-ce.repo
curl -o /etc/yum.repos.d/docker-ce.repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
这里就可以看到
可安装的软件包
* updates: mirrors.aliyun.com
Loading mirror speeds from cached hostfile
* extras: mirrors.aliyun.com
docker-ce.x86_64 3:20.10.9-3.el7 docker-ce-stable
docker-ce.x86_64 3:20.10.8-3.el7 docker-ce-stable
docker-ce.x86_64 3:20.10.7-3.el7 docker-ce-stable
docker-ce.x86_64 3:20.10.6-3.el7 docker-ce-stable
docker-ce.x86_64 3:20.10.5-3.el7 docker-ce-stable
docker-ce.x86_64 3:20.10.4-3.el7 docker-ce-stable
docker-ce.x86_64 3:20.10.3-3.el7 docker-ce-stable
docker-ce.x86_64 3:20.10.2-3.el7 docker-ce-stable
docker-ce.x86_64 3:20.10.17-3.el7 docker-ce-stable
docker-ce.x86_64 3:20.10.16-3.el7 docker-ce-stable
docker-ce.x86_64 3:20.10.15-3.el7 docker-ce-stable
docker-ce.x86_64 3:20.10.14-3.el7 docker-ce-stable
docker-ce.x86_64
- yum安装docker
yum install docker-ce-20.10.6 -y
- yum卸载docker
yum remove -y docker-xxx
安装之后就可以使用了
镜像加速器【配置ustc的加速器】
使用docker首要操作就是获取镜像文件，默认是从Docker hub下载，网速慢，国内的云服务更快
- 创建修改docker配置文件，选用七牛云镜像站
mkdir -p /etc/docker
touch /etc/docker/daemon.json
vim /etc/docker/daemon.json
再其中粘贴 :wq 可以配置其他的
{
"registry-mirrors": [
"https://docker.mirrors.ustc.edu.cn"
]
}
cat /etc/docker/daemon.json
------看到结果：
[root@localhost ~]# cat /etc/docker/daemon.json
{
"registry-mirrors": [
"https://docker.mirrors.ustc.edu.cn"
]
}
- 配置 加速器之后重新读取配置文件，并设置docker服务开机自启动
systemctl daemon-reload
systemctl enable docker //设置开机自启动
systemctl restart docker //启动docker
这个时候使用docker的命令docker version验证安装是否成功
[root@localhost ~]# systemctl daemon-reload
[root@localhost ~]# systemctl enable docker
Created symlink from /etc/systemd/system/multi-user.target.wants/docker.service to /usr/lib/systemd/system/docker.service.
[root@localhost ~]# systemctl restart docker
[root@localhost ~]# docker version
Client: Docker Engine - Community
Version: 20.10.17
API version: 1.41
Go version: go1.17.11
Git commit: 100c701
Built: Mon Jun 6 23:05:12 2022
OS/Arch: linux/amd64
Context: default
Experimental: true
Server: Docker Engine - Community
可以使用ps -ef|grep docker 查看docker进程； 查看之后可以使用
- docker ps
- docker images
- docker version
Docker生命周期
docker整个生命周期由三部分组成： 镜像image + 容器container + 仓库repository
可以以Git的思维来思考这个过程，gitHub ---- dockerHub
- Dockerfile： 构建docker镜像的文件，通过douckerfile 可以build自定义的镜像，而使用的各种基础服务的镜像比如redis等直接从registry上面拉取
- Images： 镜像，类似于虚拟机镜像，是一个只读的模板【理解为静态文件】，一个独立文件系统，包括容器运行的数据，可以用来创建新的容器，images类似于java的类，容器就是其实例化对象【一个image可以有多个container】； 获取镜像的方式： Build from dockerfile； pull from registry 【镜像实际上有一层一层的文件组成，层级文件系统UnionFS
- Containers： 容器是由镜像创建的运行实例，类似虚拟机，可以run，stop，start，容器内可以运行不同的服务，容器有自己的网络空间和自己的网络IP环境以及文件系统，和宿主机是隔离的，类似于本机上面的虚拟机，容器除了内核，软件运行的其余依赖都有， 但是对于用户来说，直接访问的是宿主机，所以需要进行端口映射和文件映射-p，-v 容器不是虚拟机（操作系统），容器就只是宿主机一个进程
- Docker Registry： Docker Hub仓库，分为公有仓库和私有仓库【类似于之前的码云，可以设置私有的和公共的，公共的都可以pull拉取源代码】 在网络环境中管理docker images
- 网络管理镜像
可以从图中看出，images和containers默认都在本地，要remote交互，就必须利用仓库进行交互，和git类似，向hub中提交镜像为 docker push ， 拉取镜像为docker pull
- 本地管理镜像
使用docker save 导出镜像为一个backup.tar压缩文件，这样将文件直接传送给别人再通过docker load生成镜像
- 本地镜像和容器管理
使用docker run可以利用固定的image生成运行一个具体的容器实例，容器的管理就是stop，start，restart等；
同时可以根据一个具体的容器实例通过docker commit 容器ID 生成一个镜像；
1. 比如获取了一个centos镜像，最小化没有软件
2.docker run centos，运行了一个带有centos服务的容器，可以进入容器内
3. 再容器内安装了一个vim
4. docker commit 容器ID 生成了一个带有vim软件的centos镜像
镜像images原理
images就是一个分层管理的文件系统
之前pull nginx的时候就可以发现细节
[root@localhost ~]# docker pull nginx
Using default tag: latest
latest: Pulling from library/nginx
a2abf6c4d29d: Pull complete
a9edb18cadd1: Pull complete
589b7251471a: Pull complete
186b1aaa4aa6: Pull complete
b4df32aa5a72: Pull complete
a0bcbecc962e: Pull complete
Digest: sha256:0d17b565c37bcbd895e9d92315a05c1c3c9a29f762b011a10c54a66cd53c9b31
Status: Downloaded newer image for nginx:latest
docker.io/library/nginx:latest
【不加tag，默认tag ： latest】pull时一共pull complete了6次，最终进行Hash校验，最终完成下载一个nginx镜像
REPOSITORY TAG IMAGE ID CREATED SIZE
nginx latest 605c77e624dd 7 months ago 141MB
通过docker images查看本地镜像发现其SIZE比普通的安装包大了许多，普通的安装包就几M
操作系统的镜像文件
网上下载的超过4G的镜像文件实际上包括两个部分： Linux内核（内核只是提供操作系统最基础的比如内存管理，进程调度，文件管理等功能】，以及上层的发行版（各厂商定制化不同的功能，比如Centos发行版）
比如可以使用cat /etc/redhat-realse 查看发行版，通过uname -r查看内核
[root@localhost ~]# cat /etc/redhat-release
CentOS Linux release 7.9.2009 (Core)
[root@localhost ~]# uname -r
3.10.0-1160.el7.x86_64
linux内核 + centos发行版 组成完整的镜像文件
在虚拟机上灵活替换不同的Linux发行版【相关发行版镜像】
宿主机本体： 笔记本+ vmware（centos7）共用宿主机的内核，使用不同发行版的docker是实现灵活切换
利用docker容器获取不同发行版的镜像，基于该镜像运行出各种不同的容器使用； 镜像只是发行版，没有内核，所以使用的是之前刻录的虚拟机映像（包含内核 和 发行版）所以占用存储大得多
首先就是下载不同的发行版, 运行docker容器并进入容器内终端执行bash命令解释命令
docker pull ubuntu
docker run -it XXXXX(ID) bash
之后就可以查看一下发行版和内核
[root@localhost ~]# docker pull ubuntu
Using default tag: latest
latest: Pulling from library/ubuntu
7b1a6ab2e44d: Pull complete
Digest: sha256:626ffe58f6e7566e00254b638eb7e0f3b11d4da9675088f4781a50ae288f3322
Status: Downloaded newer image for ubuntu:latest
docker.io/library/ubuntu:latest
[root@localhost ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
nginx latest 605c77e624dd 7 months ago 141MB
ubuntu latest ba6acccedd29 9 months ago 72.8MB
[root@localhost ~]# docker run -it ba6acccedd29 bash
root@80daf145fcdb:/# cat /etc/lsb-release
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=20.04
DISTRIB_CODENAME=focal
DISTRIB_DESCRIPTION="Ubuntu 20.04.3 LTS"
root@80daf145fcdb:/# uname -r
3.10.0-1160.el7.x86_64
可以看到运行之后就进入了容器内部的linux的Ubuntu发行版操作系统，看到发行版已经切换了，但是内核还是没有发生改变
root@80daf145fcdb:/# ls
bin boot dev etc home lib lib32 lib64 libx32 media mnt opt proc root run sbin srv sys tmp usr var
root@80daf145fcdb:/# cd etc
root@80daf145fcdb:/etc# ls
adduser.conf cron.d deluser.conf gai.conf hosts ld.so.cache login.defs mtab pam.conf rc0.d rc5.d security subgid terminfo
alternatives cron.daily dpkg group init.d ld.so.conf logrotate.d networks pam.d rc1.d rc6.d selinux subuid update-motd.d
apt debconf.conf e2scrub.conf gshadow issue ld.so.conf.d lsb-release nsswitch.conf passwd rc2.d rcS.d shadow sysctl.conf xattr.conf
bash.bashrc debian_version environment host.conf issue.net legal machine-id opt profile rc3.d resolv.conf shells sysctl.d
bindresvport.blacklist default fstab hostname kernel libaudit.conf mke2fs.conf os-release profile.d rc4.d rmt skel systemd
root@80daf145fcdb:/etc# exit
exit
[root@localhost ~]#
使用exit就可以退出容器内的终端，回到原本的虚拟机容器；这个时候也停止了该容器
docker镜像解决问题【迁移，不依赖】
如果没有docker，就需要直接在宿主机安装很多软件，可能造成的问题就是占用存储、环境不兼容，会破环当前系统的环境，卸载麻烦，迁移非常麻烦，因为系统不一样，只能在次进行各种配置
如果安装docker，解决环境问题：在容器中运行各种发行版，并且不想使用软件，直接删除容器即可，不影响宿主机 【windows + docker + 不同的容器】
如果想要将mysql容器内的数据配置全部迁移到服务器，只需要提交该容器为镜像，镜像放到服务器再运行run容器即可；
images分层原理
通过docker pull下载的一个镜像就是上述的分层结构，最终识别为一个文件是依赖的UnionFS 联合文件系统，将上述的不同的每一层整合为一个文件系统，隐藏多层的视角
上面的图中就是构建一个普通的web应用需要构建Linux内核（宿主机提供），需要运行的Linux发行版基础镜像，和更上层的jdk镜像，上面的tomcat容器依赖，最终的web程序的镜像写入可写程序，就可以直接运行web程序
- bootfs： boot file system主要包括bootloader和kernel，bootloader引导加载kernel，Linux刚启动时会加载bootfs文件， 依赖于宿主机提供的Linux内核；所以会首先加载宿主机的内核
- rootfs： 基础镜像： root-file system，获取发行版，docker获取基础镜像，rootfs就是各种不同的发行版
- 镜像： 依赖环境，比如使用centos提供的软件管理，yum install curl/nginx
- 可写容器： 具体程序运行位置，可以写入想运行的代码程序，容器层和可写层如代码修改后重启容器生效
可以看到一个镜像是包括从最底层的Linux内核、使用的发行版，和上面运行该程序需要的其他的依赖，更上层的依赖，最上层才是可写层的自定义代码，下面的几层都是只读的，不可写，只有自定义的是可写的，整个构成一个镜像；dockerfile就是一层一层构建；
- dockerfile的作用： 自定义docker镜像每一层的作用【每一层的选择】
- 当通过image启动容器，docker会在容器最顶层，添加一个读写文件系统作为容器，然后运行该容器
- docker的基础镜像很小 是因为 内核是由宿主机提供，基础镜像只是系统的发行版
- 下载nginx镜像 比安装包大 是因为 docker的nginx镜像分层，依赖于父镜像（上一层）和基础镜像，所以最终下载下来就很大【启动容器就可以运行，不用再担心环境 nginx只能运行在Linux系统上面，不能运行在windows上面】
docker镜像【每一个镜像都包含完整的层，至少包含base】
we如果自定义镜像，docker镜像不包含Linux内核，和宿主机公用；比如如果要自定义mysql8的镜像，需要先获取基础镜像，选择一个发行版平台，之后在centOS镜像中安装mysql8软件，导出镜像，命名为mysql8镜像文件
镜像从下层向上层不断添加，底层centos镜像，上层是mysql镜像，centos为父镜像
所以说我们pull拉取的每一个镜像都是包含完整的几层的，都是具有相关的依赖环境的，比如拉取的nginx肯定是包括运行nginx的发行版的，可以通过exec进入容器内部查看【】
[root@localhost ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
nginx latest 605c77e624dd 7 months ago 141MB
ubuntu latest ba6acccedd29 9 months ago 72.8MB
这里就可以解释为什么nginx镜像比ubuntu大，是因为越下层的镜像的依赖越少； 而nginx需要依赖发行版镜像，除了debian的镜像之外还有就是其他的镜像依赖
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
ab456314fbc6 nginx "/docker-entrypoint.…" 5 seconds ago Up 3 seconds 0.0.0.0:80->80/tcp, :::80->80/tcp naughty_yalow
[root@localhost ~]# docker exec -it ab456314fbc6 bash
root@ab456314fbc6:/# cat /etc/os-release
PRETTY_NAME="Debian GNU/Linux 11 (bullseye)"
NAME="Debian GNU/Linux"
VERSION_ID="11"
VERSION="11 (bullseye)"
VERSION_CODENAME=bullseye
ID=debian
HOME_URL="https://www.debian.org/"
SUPPORT_URL="https://www.debian.org/support"
BUG_REPORT_URL="https://bugs.debian.org/"
root@ab456314fbc6:/# exit
exit
[root@localhost ~]#
可以看到这个容器依赖的发行版为Debian
分层的好处
镜像分层的好处就是共享资源，比如多个镜像来自同一个base镜像，那么在docker host主机只需要存储一份base镜像即可； 内存中也只需要加载一份host为多个容器服务，多容器共享
多容器共享同一个base镜像==，某个容器修改了base镜像的内容，比如/etc下面的配置文件，其他的容器中的是不会修改的 ----- 写入时复制性==，Copy on write； 修改动作基于当个容器【CopyOnWriteArrayList也是修改时复制一份修改，最后才替换】
可写的容器层 Copy On Write
当容器启动后，一个新的可写容器会挂在到镜像的顶部，这一层被称为可写容器层，容器层下面都是只读镜像层
在容器运行时，所有对容器的修改操作，都只会发生在容器层里，其余不可修改，比如文件操作：
- 添加文件： mkdir再touch文件，新文件会添加到容器中，不会修改底层的Debian系统
- 读取文件：当需要cat文件，docker会从上到下个镜像层查找文件，一旦找到，立刻复制到容器层，打开并读入内存 【查看的只是副本】
- 修改文件，当需要修改文件，ocker会从上到下个镜像层查找文件，一旦找到，立刻复制到容器层，然后修改，【修改的只是副本】
- 删除文件： 在容器中删除文件，也是自上而下查找，找到后，在容器中记录下此删除操作 【只是记录】，不会真正删除
分层的镜像最终通过docker的UnionFS功能让用户只感知到一个完整的镜像
Docker快速使用【nginx运行
Docker的CS架构，分为客户端和服务端，客户端向服务端发命令【redis】
we通过客户端向服务端进程docker daemon发起请求，获取到镜像images，之后通过镜像加载容器containers
比如这里演示使用Nginx【web服务器，进行转发的负载均衡，运行出80端口的网站】，首先就是获取镜像，之后运行运行镜像、生成容器
如果不使用docker，在宿主机上想要运行nginx
- 开启服务器
- 在服务器上安装ngix所需要的依赖关系
- 安装nginx， 直接yum install nginx -y
- 修改nginx配置文件
- 启动nginx
- 客户端访问nginx
这比较耗费时间，还有比如安装redis，mongoDB等
使用docker方式就非常便捷：
- 从镜像站中搜索镜像
docker search nginx
--------------------搜索结果---------------
[root@localhost ~]# docker search nginx
NAME DESCRIPTION STARS OFFICIAL AUTOMATED
nginx Official build of Nginx. 17165 [OK]
linuxserver/nginx An Nginx container, brought to you by LinuxS… 169
bitnami/nginx Bitnami nginx Docker Image 137 [OK]
ubuntu/nginx Nginx, a high-performance reverse proxy & we… 55
bitnami/nginx-ingress-controller Bitnami Docker Image for NGINX Ingress Contr… 19 [OK]
rancher/nginx-ingress-controller 10
ibmcom/nginx-ingress-controller Docker Image for IBM Cloud Private-CE (Commu… 4
bitnami/nginx-ldap-auth-daemon 3
rancher/nginx 2
bitnami/nginx-exporter 2
rapidfort/nginx RapidFort optimized, hardened image for NGINX 2
vmware/nginx 2
rancher/nginx-ingress-controller-defaultbackend 2
circleci/nginx This image is for internal use
- 从上面配置的镜像站： regisrty 中拉取下载nginx镜像
docker pull nginx
- 运行该nginx镜像，运行出具体的nginx服务
docker run -d -p 80:80 nginx
运行的结果可以看到容器的创建时间，还有端口的映射情况
[root@localhost ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
4bf6ce6a687d nginx "/docker-entrypoint.…" 21 seconds ago Up 17 seconds 0.0.0.0:80->80/tcp, :::80->80/tcp pedantic_joliot
- 查看宿主机的端口active，运行的服务 netsat -tunlp
[root@localhost ~]# netstat -tunlp
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address Foreign Address State PID/Program name
tcp 0 0 0.0.0.0:111 0.0.0.0:* LISTEN 798/rpcbind
tcp 0 0 192.168.122.1:53 0.0.0.0:* LISTEN 1541/dnsmasq
tcp 0 0 0.0.0.0:22
这样虚拟机上面就完整跑了一个nginx服务
Docker镜像管理常用命令
docker search XXX 在regisry镜像站中搜索XXX镜像
这里的镜像站regisry（dockerhub，包括提供的优质的镜像和用户自己上传的镜像）就是上面镜像加速配置的json文件中的regisry，可以修改为其他的，i 使用的ustc的
[root@localhost ~]# docker search nginx
NAME DESCRIPTION STARS OFFICIAL AUTOMATED
nginx Official build of Nginx. 17165 [OK]
linuxserver/nginx An Nginx container, brought to you by LinuxS… 169
bitnami/nginx Bitnami nginx Docker Image 137 [OK]
...... 第一个的为最优选项，可以看到点赞数STARS最多并且OFFICIAL授权
docker pull XXX (:tag)
从镜像站拉取下载镜像，可以加上标签tag，不加就会默认加上latest也就是最新的软件;默认加上:latest 版本号 比如 :8.8.9
docker images （image ls）【-q】 【名称 + tag】 查看本地镜像
- -q: quit 简略显示本地的镜像
可以通过docker image ls或者docker images查看本地有所有镜像；加上具体的名称就可以进行过滤得到精确的查找结果
[root@localhost ~]# docker image ls
REPOSITORY TAG IMAGE ID CREATED SIZE
会按照上面的标签进行显示： tag为版本号， IMAGE ID为镜像的唯一标识ID
还可以使用–format进行更精确的匹配：
docker images --format "{{.ID}}--{{.Repository}}" 格式化显示（docker模板语言）只显示id和repository
docker images --format "table {{.ID}\t{{.Repository}}/t{{.Tag}}" 表格形式显示
docker rmi [docker ID前三位就可] 删除本地ID为XX的镜像【不依赖记录rm】
rmi为remove image，删除本地ID为XXX的镜像
[root@localhost docker-learn]# docker rmi 406d335e4ee6
Untagged: my-nginx:latest
Deleted: sha256:406d335e4ee65ae3a2cddb6ca78b61008438bbd65c3416b68cd30eb744b81c32
Deleted: sha256:5a0b88df2decb9221e09e728bce6b686900f6f982d6a3a2697a84b5102f1ab8a
还可以直接批量删除：
docker rmi `docker images -aq`
需要注意的是删除的镜像不能依赖于任何的容器记录，如果有，先rm相关的容器记录
docker image save XXX > XXX.tgz 导出镜像为压缩包，指定路径
导出镜像，比如默认运行的centos镜像，不提供vim功能，所以可以运行容器后，在容器内可以安装vim，然后导出为压缩包给他人使用
比如：
docker run -it centos:XXX bash
---> 进入容器内centos发行的终端
~ ： vim 【bash: vim: command not found】
~ ： yum install vim -y 【安装最新版的vim，直接yum install下载】
~ : vim 有功能了
~ : 退出返回
docker ps -a：
会显示上面关闭的容器，直接docker commit 该记录为镜像
docker image save centos:XXX > /opt/centos.XX.tgz 保存为压缩文件在/opt目录下
docker image load -i XXXX.tgz 从指定路径下导入镜像
XXXX.tgz为一个完整路径，该路径下存在导出的镜像的压缩包，导入该压缩包即可
docker image inspect 镜像ID 显示镜像的详细信息
docker info查看的是docker进程的详细信息，要查看image的详细信息，使用inspacet命令,显示的都是JSON格式的信息
[root@localhost ~]# docker image inspect 605
[
{
"Id": "sha256:605c77e624ddb75e6110f997c58876baa13f8754486b461117934b24a9dc3a85",
"RepoTags": [
"nginx:latest"
],
"RepoDigests": [
"nginx@sha256:0d17b565c37bcbd895e9d92315a05c1c3c9a29f762b011a10c54a66cd53c9b31"
],
"Parent": "",
"Comment": "",
"Created": "2021-12-29T19:28:29.892199479Z",
"Container": "ca3e48389f7160bc9d9a892d316fcbba459344ee3679998739b1c3cd8e56f7da",
"ContainerConfig": {
"Hostname": "ca3e48389f71",
"Domainname": "",
"User": "",
"AttachStdin": false,
......
Docker容器管理命令
docker run 【参数 -p -v -d -i t --rm】 镜像名称/ID 【bash等】 运行镜像生成容器(还可进入容器)
使用docker run就可以运行镜像生成容器，运行结果就是生成一个容器的ID 等同于创建+ 启动，如果镜像不存在于本地，则会在线下载镜像，容器内的进程必须处于前台运行状态（默认情况下，不加-d） ----- 也就是CTRL + C会退出【redis直接启动的状态】 比如这里，否则会直接退出；如果容器内什么都没做，容器也会挂掉
参数如下：
- -d ： 后台运行容器，就类似redis的后台运行，不会占用当前终端
- -p: portmap 端口映射， 格式： -p 宿主机端口：容器端口； 比如-p 80:80 就是访问宿主机的80端口就是访问容器的80端口
- -v： 目录映射，容器有自己的文件系统和网络环境，宿主机也是，但是访问的时候直接访问的是宿主机，而不是容器，所以网络环境需要端口映射，文件系统需要目录映射，目录映射就是访问宿主机的某目录 就会 自动映射访问容器内的某目录 -v 宿主机目录:容器目录， 在容器内访问挂载目录就是访问宿主机某个目录，二者文件夹内内容相同
- -P: 随机端口映射，随机找到宿主机的一个端口【空闲的】
- -i : 交互式命令操作，进入容器进行交互式操作
- -t： 开启一个终端
- –rm: 容器退出时自动删除容器
- –name: 给容器起名称 【会显示在docker ps中】
- bash ： 进入容器后执行的命令，Linux的命令的解释必须依赖bash，也可以是执行其他的命令 docker run --rm centos:XXX ping www.baidu.com 就是运行容器之后执行容器内执行ping命令（不会进入容器）
比如： docker -run -d -p 80:80 nginx docker -run -it XXX(Ubantu发行版的镜像ID) bash
------------------------------------------
| _________________________ |
| | 容器 | |
| | 内部运行80端口的nginx | |
| ========================| |
| 宿主机，无服务 ↑ 端口隐射，转发访问|
-------------------------------------------
↑
|
| 客户端client发起对宿主机80端口nginx服务的访问
此时宿主机80端口实际运行的是容器docker-proxy代理
tcp 0 0 0.0.0.0:80 0.0.0.0:* LISTEN 6854/docker-proxy
如果容器不是前台运行状态，则挂掉（默认情况下，不加-d）会占用一个终端
docker run nginx
xxxxx
xxxxx
CTRL + C 退出
执行docker ps 发现容器没有运行
如果容器内没有任何前台运行的进程，则挂掉
docker run centos:XX
什么都不会发生，因为centos为一个base，里面没有其他执行的进行，不会前台运行，只会记录容器记录
docker logs 【-f】 容器ID 查看容器日志
如果想要知道容器干了什么事情，就可以查看容器的日志，通过docker logs完成
- -f： 实时刷新日志，CTRL + C退出
[root@localhost ~]# docker logs ab456314fbc6
/docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
/docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
/docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
10-listen-on-ipv6-by-default.sh: info: Getting the checksum of /etc/nginx/conf.d/default.conf
10-listen-on-ipv6-by-default.sh: info: Enabled listen on IPv6 in /etc/nginx/conf.d/default.conf
/docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
/docker-entrypoint.sh: Launching /docker-entrypoint.d/30-tune-worker-processes.sh
/docker-entrypoint.sh: Configuration complete; ready for start up
docker container inspect 容器ID 查看容器详细信息
之前查看镜像详细信息也是inspect命名，docker image inspect ID ，这里就是container
[root@localhost ~]# docker container inspect ab456314fbc6
[
{
"Id": "ab456314fbc613751201f30ff99d953fb3048a67af1963c805d2c0ef3381b724",
"Created": "2022-07-29T10:07:34.080160197Z",
"Path": "/docker-entrypoint.sh",
"Args": [
"nginx",
"-g",
"daemon off;"
],
"State": {
"Status": "running",
"Running": true,
"Paused": false,
"Restarting": false,
"OOMKilled": false,
"Dead": false,
....
这里也是显示的是JSON格式的数据
docker exec -it 容器ID bash 进入容器内的发行版终端
进入到正在运行的容器内，-it还是进入交互打开终端，bash就是加载发行版Linux的基本命令的解释器，所以该命令实际就是进入到容器内运行的发行版的中终端上面
exit （容器内执行） 退出容器
如果通过 run -it进入了容器，可以直接通过exit退出容器
docker ps 【-a】 查看本地容器运行情况
这个命令可以查看本地容器的运行情况
[root@localhost ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
可以看到包含容器的ID，镜像，创建时间，端口和状态、名称等信息,只是查看正在运行的容器的信息
- -a 加上该参数可以显示所有的记录,包括正在运行的和stop的【docker ps -a】
[root@localhost ~]# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
ab456314fbc6 nginx "/docker-entrypoint.…" 57 minutes ago Up 57 minutes 0.0.0.0:80->80/tcp, :::80->80/tcp naughty_yalow
80daf145fcdb ba6acccedd29 "bash" 2 hours ago Exited (0) 2 hours ago brave_chatterjee
4bf6ce6a687d nginx "/docker-entrypoint.…" 3 hours ago Exited (0) 2 hours ago pedantic_joliot
docker port 容器ID 查看容器的端口转发情况
要想查看容器内的端口映射情况，就使用port查看
[root@localhost ~]# docker port ab456314fbc6
80/tcp -> 0.0.0.0:80
80/tcp -> :::80
docker commit 容器ID diy的镜像名 将容器提交为镜像放到本地镜像库
这里的容器ID可以通过docker ps -a 查询， diy镜像名一般是 github账号/镜像名
docker rm 镜像ID 删除镜像记录
通过该命令可以直接删除上面的-a查询到的所有的记录
[root@localhost ~]# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
ab456314fbc6 nginx "/docker-entrypoint.…" 57 minutes ago Up 57 minutes 0.0.0.0:80->80/tcp, :::80->80/tcp naughty_yalow
80daf145fcdb ba6acccedd29 "bash" 2 hours ago Exited (0) 2 hours ago brave_chatterjee
4bf6ce6a687d nginx "/docker-entrypoint.…" 3 hours ago Exited (0) 2 hours ago pedantic_joliot
[root@localhost ~]# docker rm 4bf6ce6a687d
4bf6ce6a687d
[root@localhost ~]# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
ab456314fbc6 nginx "/docker-entrypoint.…" About an hour ago Up About an hour 0.0.0.0:80->80/tcp, :::80->80/tcp naughty_yalow
80daf145fcdb ba6acccedd29 "bash" 2 hours ago Exited (0) 2 hours ago brave_chatterjee
批量删除： -q 都是简化显示
docker -rm `docker ps -aq`
docker stop 容器ID 停止容器的运行
容器运行就相当于是容器内的服务运行着，想要停止容器的运行，就使用该命令就可以停掉服务
docker start 容器ID 开启容器的运行【stop的】
docker start 容器是将stop的容器开启，和run有区别，start是用于开启，而run是创建运行
docker restart 容器ID 重启容器yunx
将正在运行的容器重启，一般就是修改配置后需要重启
docker version 查看docker的版本
可以使用该命令查看下载的docker，通过yum下载的docker，可用于验证是否下载成功
docker info 查看docker的基本信息【存储镜像位置…】
可以通过docker info查看信息，当然：信息非常多，可以通过grep进行过滤
[root@localhost ~]# docker info| grep Root
Docker Root Dir: /var/lib/docker
下面的image文件夹下面的...../sha256记录的就是镜像和容器的配置关系
可以看到docker的文件存放目录在var下面的lib下面的docker
docker build Dockerfile文件位置
可以通过该命令利用Dockerfile构建出镜像
docker tag 容器ID 自定义容器Name
dockerfile构建的容器默认情况下名称为空，指定名称就使用docker tag命令即可
docker tag XXXX my-nginx
dockerfile 常用指令
镜像是一个分层的文件系统，dockfile相当于一个脚本，通过dockerfile自己的指令，来构建软件依赖、存储…； 镜像多层存储，每一层都是在前一层的基础上进行修改，容器也是多层存储，以镜像为基础层，基础上再加一层作为容器运行时的存储层，所有的修改都保存再这一层，形成的最终的自定义的容器
定制docker镜像的方式有两种：
- 手动修改容器内容，导出新的镜像 exec -it进入，修改，commit提交为镜像
- 基于Dockerfile自行编写指令，基于指令流程创建镜像
dockerfile主要组成部分：
- 基础镜像信息： 比如 FROM centos:7.xxx
- 制作镜像操作指令： RUN yum install openssh-server -y 万能只能
- 容器启动时执行指令 : CMD【“/bin/bash”】 docker run 容器时容器内会执行的命令，比如开启服务等
需求： 虚拟机安装mysql并启动
虚拟机部署：
1. 开启虚拟机，centos7
2. 安装mysql yum install mysql-server 【部署缓慢，会占用3306端口，修改了宿主机环境，删除麻烦 --- linux】
3. 通过脚本或者命令，启动mysql
docker部署：
1. 开启虚拟机，centos7（宿主机）
2. 安装docker【如果没有】
3. 自己编写dockerfile 【或者pull定制好的镜像，但是无法自由控制base镜像，比如bae为debian】
4.运行镜像，通过端口映射 run XXX
5. 访问宿主机的映射端口，访问到容器内的mysql
dockerfile常用的指令如下：
FROM 指定base image【不一定从发行版开始构建，可以直接在任何镜像】
内核是宿主机提供，所以需要关注的最底层就是Linux的发行版，FROM就是指定base image，这里的base image不一定是发行版环境，还可以是其他的镜像的基础上继续搭建；
比如 FROM nginx； 就是在nginx这个官方镜像的基础上继续搭建属于自己的服务
MAINTAINER 指定维护者信息【可以没有】
使用MAINTAINER可以指定项目的维护者信息，用则重要，不用则不重要
RUN 构建镜像时执行的…命令
这个是最重要的指令，基础进行由FROM指定，但是上面运行的其他的依赖，都是需要下载的，还有指定yum源或者其他的安装源； 比如yum install mysql-server ----> RUN yum install mysql-server
ADD 复制宿主机文件进入容器内， 会自动解压
宿主机文件系统和容器文件系统是隔离的，再windows和linux虚拟机传递文件使用Xftp，而再宿主机和容器内使用的是ADD指令【都是隔离的，不会影响】，和COPY简单复制不同，会自动解压； gzip,bzip2，xz，tar等都会解压
- ADD 源文件 镜像目录
源文件支持URL，docker引擎会自动下载连接，放入目标路径，权限自动为600，如果为压缩文件，不会自动解压，只能RUN
ADD ceng.tgz /home/
RUN tar -zxf /opt/XXXX.tgz //会报错，因为会自动解压，没有这个压缩文件了
COPY 复制…和ADD一样
COPY命令和ADD命令的作用是相同的，只是COPY指定复制的文件仅仅复制
复制宿主机文件/目录到新的一层的镜像中
COPY指令可以保留源文件的元数据，比如权限、访问时间
- COPY 宿主机文件目录【通配，1…*】 镜像目录
COPY cfeng* /tmp/cc?.class /home/
WORKDIR 设置当前工作目录【类似cd的作用】
很多容器进入后默认是根目录，但是有些进入则是其他的目录，实现的方式就是WORKDIR
- WORKDIR /opt 改变linux下工作目录
USER 改变环境，切换用户
- USER 用户
比如USER cfeng ； 相当于在镜像操作内切换用户，和Linux直接操作命令su类似
VOLUME 设置卷，挂载主机目录【目录映射】
容器有自己的网络空间和文件系统【base image】，只是内核和宿主机共享，访问时直接访问的是宿主机的文件目录，所以需要进行目录映射，将宿主机目录挂载
容器在运行时，应该保证在存储层不写入任何数据，运行时容器内产生的数据，推荐挂载写入宿主机内，进行维护
- VOLUME 容器目录 容器运行时，自动和宿主机目录进行映射
比如 VOLUME /data 将容器内/data文件夹，容器运行时，自动挂载为匿名卷，任何向该目录写入数据的操作，都不会被容器记录，保证状态
FROM centos
MAINTAINER cfeng
VOLUME ["/data1","/data2"] 容器运行时，会自动映射到宿主机
EXPOSE 打开门，指定对外的端口，暴露端口
容器的网络空间独立，要能够进行端口映射，需要容器暴露一个端口，不暴露那容器就是一个封闭的容器，不能通过网络访问到其内部的内容
比如nginx就可以暴露80端口： EXPOSE 80
指定容器运行时对外提供的端口
ENV 【ARG】 设置容器的环境变量
env可以设置环境变量
环境变量就是整个系统都可以设置和调用的变量，在spring项目中we就是使用properties设置变量，同时可以在maven中设置变量，使用@XXXX@引用maven设置的变量
在windows系统中，在查看高级系统设置中配置环境变量，这样就可以在windows系统中使用, 使用%xxx%引用变量， 永久设置变量就在查看高级系统中设置，比如这里色湖之了
C:\Users\OMEY-PC>echo %path%
C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0;D:\MySQL\MySQL Server8.0.27\bin;D:\jdk-16\bin;";D:\Tomcat 9.0\bin;D:\Tomcat 9.0\lib";D:\Tomcat 9.0\bin;C:\Program Files\Microsoft Network Monitor 3\;D:\Maven\apache-maven-3.8.4\bin;D:\nodejs\;D:\nodejs\node_global;C:\Windows\System32\OpenSSH\；;:\Windows\System32\OpenSSH;D:\git\Git\cmd;D:\Springboot-cli\spring-2.3.1.RELEASE\bin;D:\MongoDB\Server\4.2\bin;D:\jdk-16\bin;D:\mudelsim\modelsim 10.4 crack\modelsim exe\win64;";D:\Tomcat 9.0\bin;D:\Tomcat 9.0\lib";;D:\JetBrains\IntelliJ IDEA 2019.3.2\bin;;C:\Users\OMEY-PC\AppData\Roaming\npm
这里时直接将变量给引入了，在设置的时候是使用了变量的比如： 在上面的path路径设置中就是替换了D:\jdk-16
C:\Users\OMEY-PC>echo %JAVA_HOME%
D:\jdk-16
在Linux系统中也需要设置环境变量； 比如指定安装的软件的版本
比如
yum install mysql-${mysql_version}
- ENV 变量名 变量值 通过$NAME获取变量值
ENV MYSQL_VERSION = 8.2.4
维护时直接调用即可
ARG和ENV都是设置环境变量；
ENV设置的变量，在镜像构建时，还有容器运行时都可以使用
ARG设置的变量，只能在镜像构建时使用，容器运行时消失
CMD 指定容器启动后需要执行的事情
比如nginx就是启动后执行一个entrypoint脚本文件； docker run指定的命令会覆盖CMD中指定的命令
- CMD [“参数1”,“参数2” …]
CMD["/bin/bash"] 进入容器后执行/bin下面的bash命令
执行后查看系统版本， cat /etc/os-release是两条命令
CMD["cat","/etc/os-release"]
等同于 docker run XXXX cat /etc/os-release
在指定entrypoint之后，用CMD指定具体的参数； docker不是虚拟机，容器就只是一个进程，既然是进程，程序启动时需要指定运行参数，由CMD完成
之前run 命令结尾指定的bash就是进入容器后执行的命令，如果不指定任何命令，那么就会使用设置的CMD默认命令
centos镜像默认的CMD就是/bin/bash， docker run -it centos会直接进入bash解释器，等同于docker run -it centos bash
ENTRYPOINT【传入的只是当作参数，而CMD形式为覆盖】
和RUN指令类似，分两种格式： exec和shell， 作用和CMD一样，都是指定容器启动程序以及参数
但是当指定ENTRYPONT之后，CMD指令语义发生变化, 把CMD指令的内容当作参数传递给ENTRYPONIT指令
//这里简单指定一个EntryPoint,rebuilddb代表更换yum源
FROM centos:7.8.2003
RUN rpm --rebuilddb && yum install epel-release -y
RUM rpm --rebuilddb && yum install curl -y
CMD["curl","-s","http://ipinf.io/ip"] //不会运行前台运行任何程序，所以得到结果后容器挂掉，docker ps无
启动容器
docker run centos_curl -I 该形式无法传入参数，是覆盖了dockerfile中的CMD，但是没有-I，所以就会报错
如果想要正确完成curl -s http://ipinfo.io/ip -I
- 可以直接run时传入完整的命令【覆盖】 docker run centos_curl curl -s http://ipinfo.io/ip -I
- 使用ENTRYPOINT代替CMD， CMD run时传入的只是参数
FROM centos:7.8.2003
RUN rpm --rebuilddb && yum install epel-release -y
RUM rpm --rebuilddb && yum install curl -y
ENTRYPOINT["curl","-s","http://ipinf.io/ip"]
重新构建镜像后，就可以直接传入参数使用了
docker run centos_curl -I
Dockerfile快速实践
这里我们就利用dockerfile自定义一个nginx，个性化的显示：容器启动后，生成自定义的页面
- 构建Dockerfile，文件名必须是这个
[root@localhost /]# cd ~
[root@localhost ~]# ls
anaconda-ks.cfg cfeng initial-setup-ks.cfg 公共 模板 视频 图片 文档 下载 音乐 桌面
[root@localhost ~]# cd cfeng
[root@localhost cfeng]# mkdir docker-learn
[root@localhost cfeng]# cd docker-learn/
[root@localhost docker-learn]# vim Dockerfile
这里vim Dockerfile就会创建一个Dockerfile文件，进入编辑
- 在Dockerfile中定义操作，这里比较简单，可以直接在官方的nginx基础上构建，修改nginx服务的index.html ；这里可以在Xshell中直接使用shift + insert就可以将内容粘贴到vim打开的文件中
FROM指定基础镜像，如果本地存在，就会直接使用，如果没有，那么就会去hub下载
可以看懂build过程中就直接使用了本地的ID的nginx镜像
FROM指定基础镜像，如果本地存在，就会直接使用，如果没有，那么就会去hub下载
FROM nginx
RUN echo 'Cfeng nginx Welcom to Nginx, Cfeng
' > /usr/share/nginx/html/index.html
==============================
[root@localhost docker-learn]# vim Dockerfile
[root@localhost docker-learn]# cat Dockerfile
FROM nginx
RUN echo 'Cfeng nginx Welcom to Nginx, Cfeng
' > /usr/share/nginx/html/index.html
- build 镜像 可以直接使用docker build . 因为当前目录下面就有Dockerfile，所以.即可指定， 成功后会返回要给镜像的ID
[root@localhost docker-learn]# ls
Dockerfile
[root@localhost docker-learn]# docker build .
Sending build context to Docker daemon 2.048kB
Step 1/2 : FROM nginx
---> 605c77e624dd
Step 2/2 : RUN echo 'Cfeng nginx Welcom to Nginx, Cfeng
' > /usr/share/nginx/html/index.html
---> Running in df2d56974bab
Removing intermediate container df2d56974bab
---> 406d335e4ee6
Successfully built 406d335e4ee6
- 创建出的镜像只有id，没有name，所以使用docker tag指定 名称
[root@localhost docker-learn]# docker image ls
REPOSITORY TAG IMAGE ID CREATED SIZE
- 本地运行镜像 docker -d run -p 80:80 my-nginx
[root@localhost docker-learn]# docker run -d -p 80:80 406d335e4ee6
b59b5b181bcdae17b4de0a8e94fb197b4348e73e9915994f7efe0dceedb2d346
[root@localhost docker-learn]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
b59b5b181bcd 406d335e4ee6 "/docker-entrypoint.…" 7 seconds ago Up 6 seconds 0.0.0.0:80->80/tcp, :::80->80/tcp zen_austin
现在就可以直接访问了，容器内部的窗口开放等都是原本nginx的服务，只是在其基础上进行了改动
[root@localhost docker-learn]# docker exec -it b59b5b181bcd bash
root@b59b5b181bcd:/# cd /usr/share/nginx/html
root@b59b5b181bcd:/usr/share/nginx/html# ls
50x.html index.html
root@b59b5b181bcd:/usr/share/nginx/html# cat index.html
<meta charset="utf-8"></span>Cfeng nginx<span class="token filehandle symbol"> <body style="background-color: aquamarine;">Welcom to Nginx, Cfeng