关于学习的一些思考：
对于一个工具的学习使用，其实难度都不会太大，任何技术从0到1很难，从1到后面就很容易，尤其是工具是开发出来给人使用的，肯定会尽量往简单易懂的方向发展，所以学习工具不要有畏难的心态，都不会太难。
学习途径：
1.官方文档
最佳途径肯定是研读官方文档，一般来说官方文档对于技术的解释最准确，尤其是涉及原理的解释，很利于学习者知其然知其所以然，当然如果基础比较差，读起来会比较吃力（技术，英语水平），不过这绝对是最推荐的途径。
2.看网络视频入门
如果比较懒，可以先看别人的视频帮助自己快速入门（b站免费视频，udemy的热门视频都是不错的入门途径），但是官方文档是永远的基线，还是需要再读一遍，尽量减少二手知识的摄入，这样有利于追本溯源，防止被误导，看视频对于入门是很好的方式，找到一个好视频教程省时省力，事半功倍。
3.别人的技术博客（主要是大厂技术人员资料）和专业视频分享
这种主要是针对技术细节的问题或者当下最先进的使用场景架构部署等等，这种一般官网没有，只能求助业界资深人士。
4.看专业书籍
书籍目前只推荐购买经典书籍研读，计算机行业入门书籍不推荐购买了，原因是技术更新迭代太快，很快就会过时，而且是入门书籍，也不会有太高价值，实在不行更推荐查看相关电子书。
关于发展路径的思考：
每个行业职业的发展路径是不一样的，自身所拥有的价值点也不同，要针对每个职业的价值点进行自我提升，才会让自己不断增值，成为行业的核心力量，不至于被淘汰，比如技术开发运维，价值点就是技术，谁能掌握更多最新最深层的技术，并能用技术搭建起最新的框架解决很重要的技术场景，谁就最有价值，换句话说，谁能静下心快速掌握当下最先进的技术，谁就更有价值，比如当前的技术趋势就是云原生，所有跟云原生相关的技术都是当下最先进的，比如运维（k8s+go）
关于未来技术发展趋势的思考：
以后的行业发展趋势绝对是从IAAS->PAAS->SAAS，像chatGPT就是SAAS的雏形，所以除了掌握当下流行的 k8s+go之外，熟练了解chatGPT的应用场景，产品架构，可以使用或者开发出SAAS类产品将会是未来趋势
这里先把基线贴出来：https://docs.docker.com/get-started/overview/
以下是参考狂神视频的整理
弱小和无知不是生存的障碍，傲慢才是
即使再小的帆也能远航
授人以鱼不如授人以渔
只要学不死，就往死里学
学前准备：1.linux基础 2.springboot
1.docker概述
docker作用：解决部署环境一致性，项目带上环境安装打包
传统：开发jar，运维来做
现在：开发打包部署上线，一套流程做完
java --- jar（环境）---打包项目带上环境（镜像）-------Docker仓库（商店）------下载我们发布的镜像-------直接用镜像运行容器
JRE--多个应用（端口冲突）----原来都是交叉的
隔离：Docker核心思想，打包装箱，每个箱子都是隔离的
Docker 通过隔离，将服务器资源利用到极致
本质：所有技术都是出现了一些问题，我们需要去解决，才去学习！
Docker基于Go语言开发
docker文档：https://docs.docker.com/
dockerhub镜像仓库：https://hub.docker.com/
docker和虚拟机的不同：
传统虚拟机，虚拟出一条硬件，运行一个完整的操作系统
容器内的应用直接运行在宿主机的内核，容器没有自己的内核，也没有虚拟硬件，轻便很多
每个容器间是隔离的，每个容器内都有一个属于自己的文件系统，互不影响
DevOps （开发、运维）
应用更快速的交付和部署
传统：一堆文档，安装程序
Docker：打包镜像发布测试，一键运行
更便捷的升级和扩缩容
使用了Docker之后，我们部署应用和搭积木一样
项目打包为一个镜像，扩展 服务器A，服务器B
更简单的系统运维
在容器化之后，我们的开发，测试，生产环境都是高度一致
更高效的计算资源利用
Docker是内核级别的虚拟化，可以在一个物理机上运行很多容器实例，服务器性能可以被压榨到极致
2.docker安装
Docker组成：客户端，服务器，镜像仓库
具体参考官方文档：https://docs.docker.com/get-started/overview/
镜像（images）
docker镜像好比一个模板，可以通过模板来创建容器服务，通过一个镜像可以创建多个容器
容器（container）
docker利用容器技术，独立运行一个或一组应用，通过镜像来创建
基本命令：启动、停止、删除
仓库（repository）
仓库就是存放镜像的地方
仓库分为共有仓库和私有仓库
Docker Hub(官方仓库默认在国外)
阿里云，腾讯云，都有仓库服务器（可以配置镜像加速！）
安装步骤：
这里以centos为例
环境准备
Linux要求内核3.0以上（centos7及以上）
安装
官方帮助文档：https://docs.docker.com/engine/install/centos/
其中设置安装源步骤
这里推荐使用国内yum源，速度比较快：比如阿里云
sudo yum-config-manager \ --add-repo \https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
文档最下面是卸载步骤
安装完之后可以配置镜像加速，即配置国内的镜像仓库
注：阿里或者腾讯的镜像仓库想托管自己的镜像是要收费的，这里只用来下载之用
具体配置官方文档也有说明：https://docs.docker.com/registry/recipes/mirror/#configure-the-docker-daemon
Solution🔗
The Registry can be configured as a pull through cache. In this mode a Registry responds to all normal docker pull requests but stores all content locally.
How does it work?
The first time you request an image from your local registry mirror, it pulls the image from the public Docker registry and stores it locally before handing it back to you. On subsequent requests, the local registry mirror is able to serve the image from its own storage.
What if the content changes on the Hub?
When a pull is attempted with a tag, the Registry checks the remote to ensure if it has the latest version of the requested content. Otherwise, it fetches and caches the latest content.
不同的云服务商地址不一样
这里列出腾讯云主机的加速配置：https://cloud.tencent.com/document/product/1207/45596
- 适用于 Linux 操作系统实例：
- 执行以下命令，打开
/etc/docker/daemon.json配置文件。
vim /etc/docker/daemon.json - 按 i 切换至编辑模式，添加以下内容，并保存。
{ "registry-mirrors": [ "https://mirror.ccs.tencentyun.com" ] } - 执行以下命令，重启 Docker 即可。示例命令以 CentOS 7 为例。
sudo systemctl restart docker
- 执行以下命令，打开
Docker为什么比VM快
1.Docker有着比虚拟机更少的抽象层：VM主机执行程序需要先跟虚拟系统的内核传达指令，然后经过虚拟机的翻译再传递给真实的系统内核，Docker是直接共用宿主机内核，指令直接传达给宿主机内核，减少了一层指令翻译传递的损耗，虚拟机是分钟级别，Docker是秒级
3.docker命令
帮助命令
docker verson #显示版本 docker info #显示docker系统信息 docker 命令 --help #帮助命令
命令使用方法也可以参考官网帮助文档：https://docs.docker.com/engine/reference/run/
镜像命令
docker images #查看所有本机镜像
官网文档：https://docs.docker.com/engine/reference/commandline/images/
docker images --help
docker images -aq #列出所有镜像的id（-a 列出所有，-q只列出id）
docker search 搜索镜像
例如
docker search mysql 这里的搜索结果和镜像仓库页面结果一致： https://hub.docker.com/_/mysql docker search --help #查看所有可选参数 #过滤条件搜索 docker search mysql --filter=STARS=3000 #过滤3000以上收藏的mysql项目
docker pull 下载镜像
docker pull --help #查看可选参数
docker pull mysql #下载镜像，分层下载，images核心，联合文件系统
docker pull mysql:5.7 #指定版本下载，可选版本可以参考官网dockerHub页面，这里下载由于前面下载过mysql有一部分重合部分就不会下载
docker images
docker rmi 删除镜像
docker rmi -f 镜像id/镜像名称
docker rmi -f $(docker images -aq) #查出所有镜像id，依次递归删除
docker images
docker rmi -f 镜像id 镜像id #删除多个容器
3.容器命令
说明：我们有了镜像才可以创建容器
新建容器并启动
docker run [可选参数] image
#参数说明
--name='Name' #容器名字
-d #后台方式运行
-it #使用交互方式运行，进入容器查看内容
-p #指定容器端口： -p 8080:8080
-p ip:主机端口:容器端口
-p 主机端口:容器端口（常用）
-p 容器端口
容器端口
-P #随机指定端口
例：docker run -it centos /bin/bash
exit #退出
列出所有运行的容器
docker ps #列出正在运行的容器
docker ps -a #列出所有容器，包含没运行的
-n=? #显示最近创建的容器
-q #只显示容器编号
退出容器
exit #直接停止容器并退出
ctl+P+Q #保持容器运行并登出
删除容器
docker rm 容器id #删除指定的容器，不能删除正在运行的容器，如果要删除 rm -f docker rm -f $(docker ps -aq) #删除所有的容器，包含正在运行的
docker ps -a -q|xargs docker rm -f #通过linux管道命令删除
启动和停止容器
docker start 容器id #启动 docker restart 容器id #重启 docker stop 容器id #停止 docker kill 容器id #强制停止
常用的其他命令
docker run -d 镜像名 docker run -d centos #问题 docker ps，发现 centos停止了 # 常见的坑，docker 容器使用后台运行，就必须要有一个前台进程，docker发现没有应用了，就会自动停止
查看日志
docker logs --help
docker run -d centos /bin/sh -c "while ture;do echo kuangshen;sleep 1;done"
docker logs -tf --tail 10 容器id #显示10条滚动日志#
docker logs -tf 镜像名 #显示所有日志
查看容器中的进程信息
docker top 容器id
查看镜像元数据
docker inspect 容器id
进入当前正在运行的容器
#容器一般都是用后台方式运行，需要进入容器，修改配置 docker ps docker exec -it 容器id /bin/bash #新打开一个窗口，和原窗口互不影响 docker attach 容器id #进入正在运行的窗口
从容器内拷贝文件到宿主机
dokcer cp 容器id：容器内路径 宿主机路径
例如：
docker cp 46fba3e08694:/home/test.jar /home
作业1部署nginx
docker pull nginx #下载nginx镜像 docker images #确认镜像已下载 docker run -d --name nginx01 -p 3344:80 nginx #以nginx镜像启动容器（后台运行，命名nginx01,映射容器端口80到宿主机的3344）
docker ps #确认进程已启动
curl local:3344 #在宿主机测试容器nginx是否正常
docker exec -it nginx01 /bin/bash #重新打开一个新的bash交互窗口
whereis nginx #查看nginx的配置文件
exit #退出容器
docker stop nginx01 #停止nginx01容器
作业2部署tomcat
docker run -it tomcat #启动tomcat容器，没有会自动下载镜像 docker run -it --rm tomcat:9.0 #一定要勤看官方文档，--rm命令为停止容器后，自动删除容器，一般用来测试
docker pull tomcat
docker images
docker run -d -p 3355:8080 --name tomcat01 tomcat
curl localhost:3355 #访问成功，显示404
docker exec -it tomcat01 /bin/bash #发现问题：1.linux命令不全，2.没有webapps，原因为镜像默认都为最小安装，没有必要的组件都删除，保证最小运行
cd webapp.dist #进入webapp.dist目录发现原始包
cp -r webapp.dist/* webapps #拷贝到webapps目录
ls #确认拷贝成功
curl localhost:3355 #访问端口发现页面正常
思考问题：如果webapps，conf可以在容器外部修改自动同步到容器内部就好了，有没有这种技术：docker数据卷
作业3 部署es+kibanna
参考docker hut文档：https://hub.docker.com/_/elasticsearch
#es 暴露端口很多
#es 十分耗内存
#es 的数据一般需要放到到安全目录挂载
#--net somenetwork? 网络配置
docker run -d --name elasticsearch --net somenetwork -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:tag
#启动之后发现很卡，docker stats查看 cpu状态，es十分耗内存！配置低服务器启动要谨慎
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:tag
#增加内存限制，修改启动参数，-e 环境配置修改
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2
可视化
portainer 图形化界面管理工具
rancher(CI/CD)
docker run -d -p 8088:9000 \ --restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer
测试：外网ip:8088
docker镜像
所以应用，直接打包docker镜像，就可以直接跑起来
如何得到镜像：
从远处仓库下载
朋友拷贝
自己制作镜像
Docker镜像加载原理
UnionFS（联合文件系统）
特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有体层的文件和目录
分层理解
我们去下周镜像，观察下载的日志输出，可以看到是一层一层下载
如何提交自己的镜像
commit镜像
docker commit 提交容器成为一个新的版本
#命令和git一致
docker commit -m="提交的描述信息" -a="作者" 容器id 目标镜像名:[TAG]
实战测试
1.启动一个镜像
2.做出修改
3.docker commit命令提交修改后的镜像到本地仓库
学习方式说明：理解概念，但是一定要实践，最后实践和理论相结合一次搞定
如果你想要保存当前容器的状态，就可以通过commit来提交，获得一个镜像，就好比一个快照
到了这里才算入门docker
下面是docker的精髓
docker数据卷
什么是容器数据卷
docker理念回顾
将应用和环境打包成一个镜像
数据？如果数据都在容器中，那么我们容器删除，数据就会丢失！需求：数据可以持久化
MySQL，容器删了，删库跑路！需求：Mysql数据可以存储本地
容器之间可以有一个数据共享技术！Docker容器中产生的数据，同步到本地！
这就是卷技术！目录挂载，将我们宿主机目录，挂载到容器上面！
总结：容器持久化和同步操作，容器间也是可以数据共享的
使用数据卷
方式一：之间使用命令挂载 -v
docker run -it -v 主机目录:容器目录 -p 主机端口:容器端口
docker run -it -v /home/ceshi:/home centos /bin/bash
#在容器外执行docker inspect 查看挂载信息
docker inspect 容器id
好处：以后修改配置文件只需在本地修改即可
实战：安装mysql
思考：mysql数据的持久化问题
相关镜像启动命令可以参考dockerhub说明：https://hub.docker.com/_/mysql
docker pull mysql:5.7
#运行容器，做数据挂载
docker run -d -p 3310:3306 -v /home/myql/conf:/etc/msyql/conf.d -v /home/myql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7
-d 后台运行
-p 端口映射
-v 卷挂载
-e 环境配置
--name 容器命名
#启动成功之后在外网用navicat连接服务器3310端口，可以连上
#查看文件映射路径是否成功，通过navicat创建一个数据库，查看宿主机目录文件是否同步
docker rm mysql01 #删除之后，发现本地数据依旧没有丢失
具名挂载和匿名挂载
#匿名挂载
-v 容器内路径
docker run -d -P --name nginx01 -v /etc/nginx nginx
docker volume --help
docker volume ls #查看数据卷，发现匿名挂载，-v只写了容器内的路径，没有写容器外的路径
#具名挂载
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx #juming-nginx前面没有/，表示只是个名字不是路径
docker volume ls
#查看一些这个卷
docker volume inspect juming-nginx
所有docker容器的卷，没有指定的情况下，都是在/var/lib/docker/volumes/xxxx/_data 下面
我们通过具名挂载可以方便的找到我们的卷，大多是情况用具名挂载
#如何确定是具名挂载还是匿名挂载，还是指定路径挂载
-v 容器内路径 #匿名挂载
-v 卷名:容器内路径 #具名挂载
-v 宿主机路径:容器内路径 #指定路径挂载
拓展
#通过 ro rw改变读写权限 ro 只读 rw读写
#一旦这个设置了容器权限，容器对我们挂载出来的内容就有限定了
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx:ro nginx
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx:rw nginx
#ro 只要看到ro就说明这个路径只能通过宿主机来操作，容器内部无法操作
初识Dockerfile
Docker就是用来构建docker镜像的构建文件，命令脚本
通过这个脚本可以生成镜像，镜像是一层一层的，脚本一个个的命令，每个命令都是一层
vim dockerfile01
#创建一个dockerfile文件，名字随意，建议Dockerfile，官方默认名字，不用再制定
#文件中的内容，指令（大写） 参数
#这里的每个命令，都是一层镜像
FROM centos VOLUME ["volume01","volume02"] CMD echo "--------end------" CMD /bin/bash
docker build -f dockerfile01 -t kuagnshen/centos:1.0 . #镜像名前面不能有/，后面必须有. 表明生成路径
启动自己写的容器
docker run -it 容器id /bin/bash
ls -l
#这个卷和外部目录一定是同步的
cd /volume01
touch container.txt
ctl+p+q退出容器，在宿主机执行
docker ps
docker inspect 容器id
cd /var/lib/docker/volumes/bebea6bfb92d712d28d0b83de0ec77241841de0c758b66e19199f273659023e7/_data
ls
[root@VM-4-12-centos _data]# ls
container.txt
测试一下刚才文件是否同步出去
这种方式我们未来使用 十分多，因为我们通常会构建自己的镜像
假设构建镜像时没有挂载卷，要手动挂载 -v 卷名:容器内路径
数据卷容器
两个mysql同步数据
docker ps
docker run -it --name docker02 --volumes-from 5fcb00bc2017 llcentos:1.0
cd volume01
touch test.txt
#用启动官方镜像centos通过 --volumes-from 命令
docker run -it --name docker03 --volumes-from 5fcb00bc2017 centos
touch docker03.txt
只要通过 --volumes-from，就可以建立容器间的挂载的数据卷共享
ctl+p+q退出容器
经过docker inspect命令查看三个容器的元数据，对比Mount参数列，发现三个容器Mount参数一致，得出结论，这个命令是用来复制目标节点的挂载参数的
注：这里只继承挂载的数据卷，以及支持挂载的数据卷间的文件共享，系统内部的其他文件系统没有继承关系
所以mysql数据共享可以进行如下操作，但是有个疑问，这种文件是可以共享了，但是如果两个msyql同时写一张表会不会有问题
docker run -d -p 3310:3306 -v /home/myql/conf:/etc/msyql/conf.d -v /home/myql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7
docker run -d -p 3311:3306 --volumes-from mysql01 -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 mysql:5.7
结论：
容器之间配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止
但是一旦你持久化到了本地，本地的数据就不会删除
DockerFile
DockerFile介绍
dockerfile是用来构建docker镜像的文件！命令参数脚本！
构建步骤：
1.编写一个dockerfile文件
2.docker build构建成为一个镜像
3.docker run 运行镜像
4.docker push 发布镜像（DockerHub、阿里云镜像仓库）
查看官方是怎么做的
地址如下:https://github.com/CentOS/sig-cloud-instance-images/blob/b2d195220e1c5b181427c3172829c23ab9cd27eb/docker/Dockerfile
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"]
DockerFile构建过程
基础知识
1.每个保留关键字（指令）都是必须是大写字母
2.执行从上到下顺序执行
3.#表示注释
4.每一个指令都会创建提交一个新的镜像层
dockerfile是面向开发的，我们以后要发布项目，做镜像，就需要编写dockerfile文件，这个文件十分简单！
Docker镜像逐渐成为了企业交付的标准，必须掌握
步骤：开发，部署，运维
DockerFile：构建文件，定义了一切步骤，类似源代码
DockerImages：通过DockerFile 构建生成镜像，最终发布和运行产品，类似原来的jar war
Docker容器：容器就是镜像运行起来提供服务的
DockerFile指令
以前使用别人的，现在我们可以自己编写自己的镜像
FROM #基础镜像，一切从这里开始构建
MAINTAINER #镜像是谁写的，姓名+邮箱
RUN #镜像构建的时候需要运行的命令
ADD #步骤，tomcat镜像，这个tomcat压缩包！添加内容
WORKDIR #镜像的工作目录
VOLUME #挂载的目录
EXPOSE #保留端口配置
CMD #指定这个容器启动时的运行命令,可被替代，只有最后一个会生效
ENTRYPOINT #指定这个容器启动时的运行命令,可以追加命令
ONBUILD #当构建一个被继承DockerFile 这个时候就会运行，触发指令
COPY #类似ADD，将我们文件拷贝到镜像中
ENV #构建时设置环境变量
实战测试
DockerHub中99%镜像都是从这个基础镜像过来的 FROM scratch，然后添加需要的软件和配置来进行构建
#创建一个自己的centos
docker history可以查看镜像构建历史步骤，可以研究它是怎么做的
docker images
docker history 镜像id
CMD和ENTRYPOINT的区别
测试CMD
#编写dockerfile-cmd
FROM centos CMD ["ls","-a"]
#:wq
#构建镜像
docker build -f dockerfile-cmd -t cmdtest .
#run，发现ls -a生效
docker run 镜像id
想追加一个命令
docker run 镜像id -l #运行-l报错，CMD命令 -l替换了ls -a命令，-l不是命令，所以报错
docker run 镜像id ls -al #运行ls-al成功
测试ENTRYPOINT
#编写dockerfile-entrypoint dockerfile
FROM centos
ENTRYPOINT ["ls","-a"]
#:wq
docker build -f dockerfile-entrypoint -t entrypoint-test
docker run 镜像id
docker run 镜像 id -l #运行ls -al成功
结论：CMD如果是最后一行命令会被后面的命令替换，ENTRYPOINT如果是最后一行命令，会和最后的命令一起叠加执行
Dockerfile中很多命令都十分相似，我们需要了解他们的区别，最好的方式就是对比他们然后测试效果
实战：Tomcat镜像
1.准备文件tomcat压缩包，jdk文件包
2.编写dockerfile文件，官方命名Dockerfile，build会自动寻找这个文件，就不需要-f指定了
发布自己的镜像
DockerHub
1.地址：https://hub.docker.com/，注册账号
2.确定这个账号可以登陆
docker login --help
docker login -u 账号
3.在我们的服务器上提交自己的镜像
docker push diytomcat #报错
docker tag 镜像id kuangshen/tomcat:1.0 #修改tag
docker push kuangshen/tomcat:1.0 #自己发布的镜像，尽量带上版本号
提交的时候也是按照镜像的层级提交的
阿里云镜像服务上
1.登陆阿里云
2.找到容器镜像服务
3.创建命名空间
4.创建容器镜像
5.浏览阿里云上传镜像文档按步骤做
（1）登陆阿里云镜像仓库
（2）推送到远程仓库
小结
docker网络原理
铺垫：容器编排，集群部署
idea整合daocker
docker compose
docker swarm 简化版k8s
CI/CD jenkins
$ docker run -d --name elasticsearch --net somenetwork -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:tag
