Docker学习大纲
Docker概述
Docker安装
Docker命令
镜像命令
容器命令
操作命令
...
Docker镜像！
容器数据卷！
DockerFile
Docker网络原理
IDEA整合Docker
Docker Compose
Docker Swarm
CI\CD Jenkins
Docker概述
Docker为什么出现
一款产品：开发 -> 上线 两套环境！ 应用环境
开发--> 运维。问题：我在我的电脑上可以运行！版本更新导致服务不可用！对于运维来说考验非常大，需要去联合调试，配环境
环境配置十分麻烦。每一台机器都要部署（集群Redis、ES、hadoop。。。）|费时费力。
发布一个项目（jar|php|go + (Redis Mysql jdk ES)），项目能不能带上环境安装打包
之前在服务器配置一个应用环境Redis MySQL jdk ES Hadoop，配置非常麻烦，还不能够跨平台。
windows开发。最后发布到Linux！
传统：开发java、php、go 运维来做！
现在：打开打包部署上线，一套流程做完！
举例：
java --apk --发布（应用商店）--张三使用apk---安装即可用
java --jar(环境) -- 打包项目带上环境（镜像）--（Docker仓库 ：商店）--下载发布的镜像--直接运行
Docker给以上问题他，提出了解决方案！
Docker的思想来自于集装箱！
隔离：Docker核心思想！打包装箱！每个箱子是相互隔离的
Docker通过隔离机制，可以降服务器利用到极致
Docker的历史
2021年，几个搞IT的年轻人，就在美国成立了一家公司 dot Cloud
做一些pass的云计算服务！LXC有关的容器技术！
他们将自己的技术（容器化技术）命名 就是Docker！
Docker刚刚诞生的时候，没有引起行业的注意！ dotCloud，就活不下去！
开源
开放源代码
2013年，Docker开源
Docker越来越多的人发现了Docker的优点！ 火了，Docker每个月都会更新一次
2014年4月9号，Docker1.0发布！
Docker为什么这么火？十分轻巧！
在容器技术之前，我们使用的都是虚拟机技术！
虚拟机：在window中安装Vmware或者Oracle VM VirtualBox 通过这个软件我们可以虚拟一台或者多台电脑！ 笨重！
虚拟机也是属于虚拟化技术！ Docker容器技术，也是一种虚拟化技术！
vm， Linux centos原生镜像（一个电脑！） 隔，需要开启多个虚拟机! 几个G 几分钟
docker，隔离，镜像（最和谐的黄金4m + jdk+mysql）十分的小巧，运行镜像就可以了！小巧 几个M kb 秒级启动Docker现在是所有开发人员必备技能
聊聊Docker
docker基于Go语言开发的！开源项目！
文档地址：https://docs.docker.com/ Docker文档超级详细！
仓库地址：https://hub.docker.com/ docker push
Docker能干什么
之前的虚拟机技术
虚拟技术缺点：
1、资源占用十分多
2、冗余步骤多
3、启动很慢！
现在的容器技术
比较Docker和虚拟机技术的不同：
传统虚拟机，虚拟出一条硬件，运行一个完整的操作系统，然在这个系统上安装和运行软件
容器的应用直接运行在宿主机的内容，容器是没有自己的内核的，也没有虚拟我们的硬件，所以就轻便
每个容器间是相互隔离，每个容器内都有一个属于自己的文件系统，互不影响
DevOps(开发、运维)
应用更快速的交付和部署
传统：一对帮助文档、安装程序
Docker：打包镜像发布测试，一键运行
更便携的升级和扩缩容
使用了Docker之后，我们的部署就像和搭积木一样！
项目打包为一个镜像，扩展服务器A! 直接在服务器B运行docker
更简单的系统运维
在容器化之后，我们的开发，测试环境都是高度一致。
更高效的计算资源利用
Docker是内核级别的虚拟化，可以在一个物理机上可以运行很多的容器示例！服务器的性能可以被压榨到极致。
Docker的安装
Docker的基本组成
镜像（image）:
docker镜像就好比是一个模板。可以通过这个模板来创建容器服务，tomcat镜像===> run ===> tomcat1 容器（提供服务器），通过这个镜像可以创建多个容器（最终服务运行或者项目运行就是在容器中的）。
容器（container）：
Docker理由容器技术，运行一个或者一个组的应用，通过镜像来创建的。
启动，停止，删除，基本命令！
目前就可以吧这个容器理解为就是一个简易的Linux系统
仓库（repository）:
仓库就是存放镜像的地方！
仓库分为公有仓库和私有仓库！
Docker Hub(默认是国外的)
阿里云..... 等都有容器服务器（配置镜像加速！）
安装Docker
环境准备
1、需要会一点点的Linux基础
2、Centos 7
3、我们使用Xshell连接远程服务器进行操作！（远程连接操作工具不限制）
环境查看
# 系统内核是3.10以上
[root@docker ~]# uname -r
3.10.0-1127.19.1.el7.x86_64系统版本
[root@docker ~]# 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、更新yum软件包索引
yum makecache fast
#5、安装docker相关的 docker-ce社区 ee企业版
yum install docker-ce docker-ce-cli containerd.io
#6、启动docker
systemctl enable docker && systemctl start docker
#7、使用docker version是否安装成功
#8、hello-word
docker run hello-world
#9、查看一下下载的这个 hello-world 镜像
[root@docker ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
hello-world latest feb5d9fea6a5 2 months ago 13.3kB了解：卸载docker
#1、卸载依赖
yum remove docker-ce docker-ce-cli containerd.io
#2、删除资源
rm -rf /var/lib/docker
# /var/lib/docker 的默认工作路径
#3、删除容器
rm -rf /var/lib/containerd阿里云镜像加速
1、登录阿里云找到容器服务
2、找到容器镜像服务
3、配置使用
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
"registry-mirrors": ["https://yirr4xo9.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker回顾HelloWorld流程
run的运行流程图
底层原理
Docker到底是怎么工作的？
Docker是一个 Client-Server结构的系统，Docker的守护进程运行在主机上。通过Socket冲客户端访问！
DockerServer接收到Docker-Client的指令，就好执行这个命令
Docker为什么比虚拟机快
1、Docker有着比虚拟机最少的抽象层
所以说，新建一个容器的时候，docker不需要向虚拟机一样重新加载一个操作系统内核，避免引导，虚拟机是加载Cent OS，分钟级别的，而docker是利用宿主机的操作系统，省略了这个复杂的过程，秒级！
Docker的常用命令
帮助命令
docker version # 显示docker的版本信息
docker info # 显示Docker的系统信息，包括进行和容器的信息
docker --help # 万能命令 帮助命令帮助文档地址：https://docs.docker.com/reference/
镜像命令
docker images # 查看本地主机的所有镜像
[root@docker ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
hello-world latest feb5d9fea6a5 2 months ago 13.3kB
# 解释
REPOSITORY 镜像的仓库源
TAG 镜像的标签
IMAGE ID 镜像的ID
CREATED 镜像的创建时间
SIZE 镜像的的大小
# 可选项
-a, --all # 列出所有镜像
-q, --quiet # 只显示镜像的iddocker search搜索镜像
[root@docker ~]# docker search mysql
NAME DESCRIPTION STARS OFFICIAL AUTOMATED
mysql MySQL is a widely used, open-source relation… 11803 [OK]
mariadb MariaDB Server is a high performing open sou… 4492 [OK]
# 可选项，通过收藏来过滤
--filter=STARS=3000
[root@docker ~]# docker search mysql --filter=STARS=3000
NAME DESCRIPTION STARS OFFICIAL AUTOMATED
mysql MySQL is a widely used, open-source relation… 11803 [OK]
mariadb MariaDB Server is a high performing open sou… 4492 [OK] docker pull 下载镜像
# 下载镜像 docker pull 镜像名称[:tag]
[root@docker ~]# docker pull mysql
Using default tag: latest # 如果不写tag,默认下载latest
ffbb094f4f9e: Pull complete # 分层下载。 docker image的核心 联合文件系统
df186527fc46: Pull complete
fa362a6aa7bd: Pull complete
5af7cb1a200e: Pull complete
949da226cc6d: Pull complete
bce007079ee9: Pull complete
eab9f076e5a3: Pull complete
8a57a7529e8d: Pull complete
b1ccc6ed6fc7: Pull complete
b4af75e64169: Pull complete
3aed6a9cd681: Pull complete
23390142f76f: Pull complete
Digest: sha256:ff9a288d1ecf4397967989b5d1ec269f7d9042a46fc8bc2c3ae35458c1a26727 #签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest #真实地址
# 等价于下面介绍
docker pull mysql
docker pull docker.io/library/mysql:latest
docker rmi 删除镜像
docker rmi -f 镜像id #删除指定的镜像
docker rmi -f 镜像id 镜像id 镜像id #删除多个的镜像
docker rmi -f $(docker imges -aq) #删除全部的镜像容器命令
说明：我们有了镜像才可以创建容器，Linux，下载一个centos镜像来测试学习
docker pull centos新建容器并且启动
docker run [可选参数] image
# 参数说明
--name="Name" 容器名字 tomcat1 tomcat2
-d 后台方式运行
-it 使用交互方式运行，进入容器查看内容
-p 指定容器的端口 -p 8080:8080
-p ip:主机端口:容器端口
-p 主机端口:容器端口
-p 容器端口
容器端口
-P 随机指定端口
# 测试、启动并进入容器
[root@docker ~]# docker run -it centos /bin/bash
[root@f09a8c6e7559 /]# ls # 查看容器里面的centos,基础版本，很多命令都不完善
bin dev etc home lib lib64 lost+found media mnt opt proc root run sbin srv sys tmp usr var
# 从容器中退回到主机
[root@f09a8c6e7559 /]# exit
exit
[root@iZbp1amv9wo6c6jn9z68uyZ /]# 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@docker /]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
[root@docker /]# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
f09a8c6e7559 centos "/bin/bash" 4 minutes ago Exited (127) 2 minutes ago charming_hodgkin
a32c0af1b5db feb5d9fea6a5 "/hello" 9 days ago Exited (0) 9 days ago mystifying_bell
bc0cc78523ce feb5d9fea6a5 "/hello" 11 days ago Exited (0) 11 days ago nifty_meitner
[root@docker /]# 退出容器
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@docker /]# docker run -d centos
#问题docker ps, 发现centos停止了
#常见的坑：docker 容器使用后台运行，就必须要有一个前台进程，docker发现没有应用，就好自动停止
#Nginx，容器启动后，发现自己没有提供服务，就会立刻停止，就是没有程序了查看日志
docker logs -tf --tail 容器id, 没有日志
# 自己写一段shell脚本
[root@docker /]# docker run -d centos /bin/sh -c "while true;do echo hello;sleep 1;done"
[root@docker /]# docker ps
CONTAINER ID IMAGE
fa2786d47db7 centos
# 显示日志
-tf 显示日志
--tail number 显示日志的条数
[root@docker /]# docker logs -tf --tail 10 fa2786d47db7查看容器中进程信息
# 命令 docker top 容器id
[root@docker /]# docker top fa2786d47db7
UID PID PPID C STIME TTY root 8210 8163 0 21:57 ? root 9713 8210 0 22:06 ? 查看镜像的元数据
# 命令
docker inspect 容器id
#测试
[root@docker /]# docker inspect fa2786d47db7
# ... 下面显示一堆与之容器相关的信息进入当前正在运行的容器
#我们通常容器都是使用后台方式运行的，需要进入容器，修改一些配置
# 命令
docker exec -it 容器id /bin/bash
# 测试
[root@docker /]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
fa2786d47db7 centos "/bin/sh -c 'while t…" 22 minutes ago Up 22 minutes awesome_hopper
[root@docker /]# docker exec -it fa2786d47db7 /bin/bash
[root@docker /]# ls
bin dev etc home lib lib64 lost+found media mnt opt proc root run sbin srv sys tmp usr var
[root@docker /]# ps -ef
UID PID PPID C STIME TTY TIME CMD
root 1 0 0 13:57 ? 00:00:00 /bin/sh -c while true;do echo hello;sleep 1;done
root 1357 0 0 14:19 pts/0 00:00:00 /bin/bash
root 1392 1 0 14:19 ? 00:00:00 /usr/bin/coreutils --coreutils-prog-shebang=sleep /usr/bin/sleep 1
root 1393 1357 0 14:20 pts/0 00:00:00 ps -ef
# 方式二
docker attach 容器id
#测试
[root@docker ~]# docker attach fa2786d47db7
正在执行的当前代码...
# docker exec #进入容器后开启一个新的终端，可以在里面操作（常用）
#docker attach # 进入容器正在执行的终端，不会启动新的进程！从容器内拷贝文件到主机上
docker cp 容器id:容器内路径 目的的主机路径
#进入docker容器内部
[root@docker ~]# docker exec -it fa2786d47db7 /bin/bash
[root@fa2786d47db7 /]# ls
bin dev etc home lib lib64 lost+found media mnt opt proc root run sbin srv sys tmp usr var
[root@fa2786d47db7 /]# cd /home
[root@fa2786d47db7 home]# ls
# 在容器内新建一个文件
[root@fa2786d47db7 home]# touch test.java
[root@fa2786d47db7 home]# ls
test.java
#退出容器
[root@fa2786d47db7 home]# exit
exit
[root@docker ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
fa2786d47db7 centos "/bin/sh -c 'while t…" 33 minutes ago Up 33 minutes awesome_hopper
#拷贝容器内的文件
[root@docker ~]# docker cp fa2786d47db7:/home/test.java /home/
[root@docker ~]# ls /home/
test.java 小结
与镜像有关的命令
docker tag 源镜像:版本 ：为一个镜像打标签，相当于一个镜像的新版本
docker history 镜像名称:镜像版本：查看镜像历史，更迭变化
docker images：列出全部镜像列表
docker rmi 镜像名称：镜像版本：删除镜像，加-f参数强制删除镜像
docker pull 镜像名称[：标签]：从镜像仓库中拉取镜像或者仓库
docker push 镜像名称：将一个镜像推送到镜像注册服务器
docker load ：从一个 tar 包中加载一个镜像
docker import ：从一个tar中加载内容，从而创建一个镜像
docker load用来载入镜像包，docker import用来载入容器包，但两者都会恢复为镜像；docker load不能对载入的镜像重命名，而docker import可以为镜像指定新名称。
与容器有关的命令
docker ps ：列出宿主主机上的容器
docker stop 容器名或ID：停止容器的运行，加上-t 参数可以让容器在停止前保存状态，默认为10秒
docker start 容器名或ID，docker restart 容器名或ID：开启容器，重新启动容器
docker pause 容器名或ID，docker unpause 容器名或ID：暂停容器中的所有进程，撤销暂停
docker rm 容器ID：删除一个或多个容器，-f参数强制删除一个容器，-l参数删除指向的连接，-v参数删除与该容器相关的卷
docker rename 旧名 新名称：重命名容器
docker kill 容器ID：关闭一个运行中的容器 (包括进程和所有相关资源)
docker stats 容器ID：输出（一个或多个）容器的资源使用统计信息，不写容器ID，默认输出所有运行中的容器资源使用情况
docker logs 容器ID:查看容器日志
docker top 容器ID：查看容器中正在运行的进程信息
docker diff 容器ID：查看容器中文件的变化情况，是增加了文件，还是改变了文件，等等
docker inspect 容器ID：查看容器的具体配置信息，配置位置等等信息
docker update 容器ID：更新容器的配置信息
docker exec -it 容器名 bash;与容器进行交互，也就是进入容器内执行一些命令
docker cp 本地文件路径 容器ID或名称:容器路径：将本机文件复制到容器中
docker container cp [OPTIONS] CONTAINER:SRC_PATH DEST_PATH：将容器中的文件复制到本地机中
docker export 容器名或ID：导出容器内容为一个 tar 包
docker save ：将一个或多个镜像保存为tar 文件，例如：docker save -o n.tar nginx:v3
docker save和docker export的区别：docker save保存的是镜像（image），docker export保存的是容器（container）；
与仓库有关的命令
docker login -u 用户名 -p 密码;登录到docker镜像仓库
docker logout;从docker仓库中退出登录
docker search 镜像;在docker仓库中搜索镜像作业练习
Docker安装Nginx
#1、搜索镜像，建议到官网搜索 https://hub.docker.com/
docker search 镜像名称
#2、下载镜像 pull
docker pull nginx
#3、运行测试
[root@izwz90nnowex5h4yifby67z ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
nginx latest 605c77e624dd 8 days ago 141MB
centos latest 5d0da3dc9764 3 months ago 231MB
# -d 后台运行
# --name 给容器一个名字
# -p 宿主机端口:容器内容端口
[root@docker ~]# docker run -d --name nginx01 -p 3344:80 nginx
87c0b0660f01e34060ecc460ac77c2b73d4a8650d24d02c4bf7040f9f6f9dd69
[root@docker ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
87c0b0660f01 nginx "/docker-entrypoint.…" 4 seconds ago Up 4 seconds 0.0.0.0:3344->80/tcp nginx01
[root@docker ~]# curl localhost:3344
#进入容器
[root@docker ~]# docker exec -it nginx01 /bin/bash
root@87c0b0660f01:/# whereis nginx
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx
root@87c0b0660f01:/# 
作业：docker来安装一个tomcat
#官方使用
docker run -it --rm tomcat:9.0
#我们之前的启动都市后台，停止了容器之后，容器还可以查的到
docker run -it --rm 镜像名称:版本号 #一般用来测试用完就删除
#下载在启动
docker pull tomcat
#启动运行
docker run -d -p 3355:8080 --name tomcat01 tomcat
#进入容器
[root@docker ~]# docker exec -it tomcat01 /bin/bash
#发现问题：1、Linux命令少。 2、没有webapps. docker镜像默认是最小镜像,所有不必要的都删除
#保证最小可运行环境！我们是可以在容器外部提供一个映射路径，webapps,我们在外部放置项目，就自动同步到内部就好了
作业：部署es + kibana
#es暴露端口很多！
#es十分的耗内存
#es的数据一般需要放置到安全目录
# --net somenetwork 网络配置
#启动 elasticsearch
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.16.2
#启动了 Linux就卡住了 docker stats查看cpu的状态
# 测试一下es是否成功了
[root@docker ~]# curl localhost:9200
{
"name" : "b47b57d18879",
"cluster_name" : "docker-cluster",
"cluster_uuid" : "tdInQiq9SnSJcCSDQK35QA",
"version" : {
"number" : "7.16.2",
"build_flavor" : "default",
"build_type" : "docker",
"build_hash" : "2b937c44140b6559905130a8650c64dbd0879cfb",
"build_date" : "2021-12-18T19:42:46.604893745Z",
"build_snapshot" : false,
"lucene_version" : "8.10.1",
"minimum_wire_compatibility_version" : "6.8.0",
"minimum_index_compatibility_version" : "6.0.0-beta1"
},
"tagline" : "You Know, for Search"
}
#es是十分耗内存的，最低配置 2核4G的机器
#查看 docker stats
#赶紧关掉，增加内存限制
# 关闭，增加内存限制，修改配置文件 -e 环境配置修改
docker run -d --name elasticsearch02 -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.16.2
[root@docker ~]# curl localhost:9200
{
"name" : "dd35310c16a6",
"cluster_name" : "docker-cluster",
"cluster_uuid" : "JNFQOzXERASnhHMi-CKQNw",
"version" : {
"number" : "7.16.2",
"build_flavor" : "default",
"build_type" : "docker",
"build_hash" : "2b937c44140b6559905130a8650c64dbd0879cfb",
"build_date" : "2021-12-18T19:42:46.604893745Z",
"build_snapshot" : false,
"lucene_version" : "8.10.1",
"minimum_wire_compatibility_version" : "6.8.0",
"minimum_index_compatibility_version" : "6.0.0-beta1"
},
"tagline" : "You Know, for Search"
}作业：使用kibana连接es? 思考网络如何连接
可视化
此内容一般用不到
portainer（先暂时用这个--一般不使用这个管理）
docker run -d -p 8088:9999 \
--restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainerRancher（CI/CD再用）
什么是portainer？
Docker图形化界面管理工具！提供一个后台面板供我们使用！
访问测试：http://ip:8088
这种东西不会用，安全也是个问题。放到虚拟机落灰就行
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等等。
平时我们安装虚拟机的centos都是好几个G，为什么docker这个才200M
[root@docker ~]# docker images centos
REPOSITORY TAG IMAGE ID CREATED SIZE
centos latest 5d0da3dc9764 3 months ago 231MB对以一个精简的OS，rootfs可以很小，只需要包括最基本的命令、工具和程序库就行，因为底层直接用host和kernel，自己只需要提供rootfs就行。由此可见对于不同的Linux发行版，bootfs基本是一致的，rootfs会有差别，因此不同的发行版可以公用bootfs。
分层理解
分层的镜像
以pull为例，在下载的过程中我么可以看到docker的镜像好像是在一层一层的下载
[root@docker ~]# docker pull redis
Using default tag: latest
latest: Pulling from library/redis
a2abf6c4d29d: Already exists
c7a4e4382001: Pull complete
4044b9ba67c9: Pull complete
c8388a79482f: Pull complete
413c8bb60be2: Pull complete
1abfd3011519: Pull complete
Digest: sha256:db485f2e245b5b3329fdc7eff4eb00f913e09d8feb9ca720788059fdc2ed8339
Status: Downloaded newer image for redis:latest
docker.io/library/redis:latest问题：为什么才有这种分层的结构？？
最大一个好处就是——共享资源
比如：有多个镜像都从相同的base镜像构建而来，那么宿主机只需要在磁盘上保存一份base镜像，同时内存中也需要加载一份base镜像，就可以为所有服务器服务了。而且镜像的每一层都可以被共享。
查看镜像分层的方式可以通过docker image inspect redis:latest
[root@docker ~]# docker image inspect redis:latest
[
// ...
"RootFS": {
"Type": "layers",
"Layers": [
"sha256:2edcec3590a4ec7f40cf0743c15d78fb39d8326bc029073b41ef9727da6c851f",
"sha256:9b24afeb7c2f21e50a686ead025823cd2c6e9730c013ca77ad5f115c079b57cb",
"sha256:4b8e2801e0f956a4220c32e2c8b0a590e6f9bd2420ec65453685246b82766ea1",
"sha256:529cdb636f61e95ab91a62a51526a84fd7314d6aab0d414040796150b4522372",
"sha256:9975392591f2777d6bf4d9919ad1b2c9afa12f9a9b4d260f45025ec3cc9b18ed",
"sha256:8e5669d8329116b8444b9bbb1663dda568ede12d3dbcce950199b582f6e94952"
]
},
// ...
}
]理解：
所有的Docker镜像都起始于一个基础镜像层，当进行修改或增加新的内容时，就会在当前镜像层之上，创建新的镜像层。分层时有文件更新直接替换，基础镜像一样时直接拿过来复用。
举一个简单的例子，假如基于 Ubuntu16.04创建一个新的镜像，这就是新镜像的第一层。如果在该镜像中添加Python包，就会在基础镜像层之上创建第二个镜像层。如果继续添加一个安全补丁，就会创健第三个镜像层该像当前已经包含3个镜像层，如下图所示（这只是一个用于演示的很简单的例子）。
在添加额外的镜像层的同时，镜像始终保持是当前所有镜像的组合。一个简单的例子，每个镜像层包含3个文件，而镜像包含了来自两个镜像层的6个文件。
上图中的镜像层跟之前的图中的略有区别，主要的目的是便于展示文件。
下图中展示了一个稍微复杂的三层镜像，在外部看来整个镜像只有6个文件，这是因为最上层中的文件7是文件5的一个更新版。
这种情况下，上层镜像层中的文件覆盖了底层镜像层中的文件。这样就使得文件的更新版本作为一个新镜像层添加到镜像当中。
Docker通过存储引擎（新版本采用快照机制）的方式来实现镜像层堆栈，并保证多镜像层对外展示为统一的文件系统。
Linux上可用的存储引擎有AUFS、Overlay2、Device Mapper、Btrfs以及ZFS。顾名思义，每种存储引擎都基于Linux中对应的文件系统或者设备技术，并且每种存储引擎都有其独有的性能特点。
Docker在window上仅支持windowsfilter一种存储引擎，改引擎基于NTFS文件系统之上实现了分层和Cow.
下图展示了所有镜像层堆并合井，对外提供统一的视图。
特点
Docker镜像都是只读的，当容器启动时，一个新的可写层加载到镜像的顶部。
这一层就是我们通常说的容器层，容器之下的都叫镜像层。
commit镜像
提交一个自己的镜像
docker commit 提交容器成为一个新的副本
# 命令和git原理类似
docker commit -m="提交描述" -a="作者" 容器id 目标镜像名称:[tag]实战测试
# 1、启动一个默认的tomcat
# 2、发现这个默认的tomcat是没有webapps应用，官方的镜像默认webapps下面是没有文件的
# 3、拷贝文件进去
# 4、将操作过的容器通过commit提交为一个镜像。我们以后就使用我们修改过的镜像即可，这就是我们自己的一个修改的镜像。
[root@docker ~]# docker commit -a="auther" -m="add webapps app" 42270878202d tomcat02:1.0
sha256:53fa8e6ba3771c05d4a06b064702a4346ae68bed613df73136a6b9f26a7d4c1e
[root@docker ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
tomcat02 1.0 53fa8e6ba377 9 seconds ago 684MB
nginx latest 605c77e624dd 9 days ago 141MB
tomcat 9.0 b8e65a4d736d 2 weeks ago 680MB容器数据卷
什么是容器数据卷
数据，如果数据都在容器中，那么我们容器上传，数据就会丢失！ 需求：数据可持久化
Mysql，容器删除了，相当于删库跑路！需求：MySQL数据可以存储在本地！
容器之间可以有一个数据共享的技术！Docker容器中产生的数据，同步到本地！
这就是卷技术！其实就是目录挂载，将我们容器内的目录，挂载到Linux上面！
总结一句话：容器的持久化和同步操作！容器间也是可以数据共享的
使用数据卷
方式一：直接使用命令来挂载 -v
docker run -it -v 主机目录:容器内目录
#测试
[root@docker home]# docker run -it -v /home/ceshi:/home centos /bin/bash、
#启动之后我们可以通过 docker inspect 容器id
测试文件的同步
好处：我们以后修改只需要在本地修改即可，容器内会自动同步！
实战：安装MySQL
思考：mysql的数据持久化的问题！
#获取镜像
[root@docker home]# docker pull mysql:5.7
#运行容器，需要做数据挂载！ #安装启动mysql，需要配置密码的，这是需要注意的点
#官方测试：docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag
#启动我们的
-d 后台运行
-p 端口映射
-v 卷挂载
-e 环境配置
--name 容器名字
[root@docker home]# 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
#启动成功之后，在本地使用Navicat来连接测试一下
# Navicat连接到服务器的3310 --- 3310 和容器内的3306映射，这个时候我们就可以连接上。 假设我们将容器删除
[root@docker data]# docker rm mysql01
mysql01
[root@docker data]# ls
auto.cnf ca.pem client-key.pem ibdata1 ib_logfile1 performance_schema public_key.pem server-key.pem
ca-key.pem client-cert.pem ib_buffer_pool ib_logfile0 mysql private_key.pem server-cert.pem sys发现，我们挂载到本地的数据卷依旧没有丢失，这就实现了容器数据持久化功能！
具名和匿名挂载
# 匿名挂载
-v 容器内路径！
docker run -d -P --name nginx01 -v /etc/nginx nginx
#查看所有卷volume的情况
[root@docker data]# docker volume ls
DRIVER VOLUME NAME
local 2a2a4d3192fbbc3abd4f256e24f1102477acc1bf92a30939aa16e44f0232ac77
#这里发现，这种就是匿名挂载，我们在 -v 只写了容器内的路径，没有写容器外的路径！
#具名挂载
[root@docker data]# docker run -d -P --name nginx01 -v juming-nginx:/etc/nginx nginx
4245bf0d6ba50ac85a0c70063def2bf1b8cf409121b441e94843046f806be783
[root@docker data]# docker volume ls
DRIVER VOLUME NAME
local juming-nginx
# 通过 -v 卷名:容器内路径
#查看一下这个卷
[root@docker data]# docker volume inspect juming-nginx
[
{
"CreatedAt": "2022-01-08T21:31:07+08:00",
"Driver": "local",
"Labels": null,
"Mountpoint": "/var/lib/docker/volumes/juming-nginx/_data",
"Name": "juming-nginx",
"Options": null,
"Scope": "local"
}
]所有docker的容器内的卷，没有指定目录的情况下都是在 /var/lib/docker/volumes/xxx/_data
我们通过具名挂载可以方便的找到我们的一卷，大多数情况下都在使用的 具名挂载
#如何确定是具名挂载，还是指定路径挂载！
-v 容器内距离 #匿名挂载
-v 卷名:容器内路径 #具名挂载
-v /宿主机路径:容器内路径 #指定路径挂载拓展：
# 通过 -v 容器内路径：ro rw改变读写权限
ro readonly #只读
rw readwrite #可读可写
docker run -d -P --name nginx01 -v juming-nginx:/etc/nginx:ro nginx
docker run -d -P --name nginx01 -v juming-nginx:/etc/nginx:rw nginx
#ro 只要看到ro就说明这个路径只能通过宿主机来操作，容器内部就是无法操作！初识Dockerfile
Dockerfile 就是用来构建docker镜像的构建文件! 命令脚本！先体验一下！
通过这个脚本就可以生成一个镜像，镜像是一层一层，脚本的命令是一个一个的
#创建一个dockerfile文件，文件名字可以随意 建议Dockerfile
#文件中的内容 指令（大写）参数
FROM centos
VOLUME ["volume01","volume02"]
CMD echo "------end-----"
CMD /bin/bash
#这里的每一个命令，就是镜像的一层
#启动一下自己生成的容器
这个卷的目录外面一定有一个同步的目录
查看一下这卷挂载的路径
测试一下刚才的文件是否同步了
这种方式我们未来使用的十分多，因为我们通常会构建自己的镜像！
加上构建镜像时候没有挂载卷，要自动镜像挂载 -v 卷名:容器内路径！
数据卷容器
多个mysql同步数据！
启动3个镜像测试游戏
docker run -it --name docker01 mystudy/centos:1.0
# --volumes-from 同步docker01的数据内容
docker run -it --name docker02 --volumes-from docker01 mystudy/centos:1.0
docker run -it --name docker03 --volumes-from docker01 mystudy/centos:1.0
#测试、可以上传docker01，查看一下docker02和docker03是否还可以访问这个文件
#测试依旧可以访问
多个mysql实现数据共享
[root@docker home]# 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
[root@docker home]# docker run -d -p 3310:3306 -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-from mysql01 mysql:5.7
#这个时候，可以实现两个容器数据同步结论：
容器之间的配置信息的传递，数据卷容器的什么周期一直持续到没有容器使用为止
Dockerfile
Dickerfile介绍
dockerfile是用来构建docker镜像的文件！命令参数脚本！
构建步骤：
1、编写一个dockerfile文件
2、docker build 构建成为一个镜像
3、docker run 运行镜像
4、docker push 发布镜像（DockerHub、阿里云镜像仓库）
Dockerfile构建过程
基础知识：
1、每个保留关键词（指令）都必须是大写字母
2、执行从上到下顺序执行
3、# 表示注释
4、每一个指令都会创建提交一个新的镜像层，并提交！
dockerfile是面向开发的，我们以后要发布项目，做镜像，就需要编写dockerfile文件。
Docker镜像 逐渐成为了企业交付的标准，必须掌握！
DockerFile的指令
FROM #基础镜像，一切从这里开始构建 centos
MAINTAINER #镜像是谁写的，姓名+邮箱
RUN #镜像构建的时候需要运行的命令
ADD #步骤：tomcat,这个tomact压缩包！添加内容
WORKDIR #镜像工作目录
VOLUME #挂载目录位置
EXPOSE #暴露端口
CMD #指定容器启动的时候要运行的命令
ENTRYPOINT #指定这个容器启动的时候要运行的命令吗，可以追加命令
ONBUILD #当构建一个呗继承Dockerfile这个时候就会运行ONBUILD
COPY #类似ADD,将我们的文件拷贝到镜像中
ENV #构建的是时候设置环境变量！ es
实战测试
Docker Hub中99%镜像都是从这个基础镜像过来的FROM scratch，然后配置需要的软件和配置来进行的构建
创建一个自己的的centos
# 1、编写Dockerfile文件
FROM centos
MAINTAINER study<xxxxx@xx.com>
ENV MYPATH /usr/local
WORKDIR $MYPATH
RUN yum -y install vim
RUN yun -y install net-tools
EXPOSE 80
CMD echo $MYPATH
CMD echo "-----end-----"
CMD /bin/bash
#2、通过这个文件构建镜像
#命令 docker build -f Dockerfile -t 镜像名:[tag] .
#3、测试运行对比：之前的原始centos
我们平时可以拿到一个镜像，可以研究一下他是怎么做的？
CMD和ENTRYPOINT 区别
CMD #指定这个容器启动的诋毁要运行的命令，只有最后一个会生效，可以被代替
ENTRYPOINT #指定这个容器启动的时候要运行的命令，可以追加命令测试CMD
#编写dockerfile文件
FROM centos
CMD ["ls","-a"]
#构建镜像
[root@docker ceshi]# docker build -f dockerfile-cmd -t cmdcentos:1.0 .
[root@docker ceshi]# docker run 06df651cece3
.
..
.dockerenv
bin
dev
#想追加一个命令 -l ls -al
[root@docker ceshi]# docker run 06df651cece3 -l
docker: Error response from daemon: OCI runtime create failed: container_linux.go:380: starting container process caused: exec: "-l": executable file not found in $PATH: unknown.
#cmd的清理下 -l 替换了CMD ["ls","-a"]命令，-l不是命令所以报错测试ENTRYPOINT
#编写dockerfile文件
FROM centos
ENTRYPOINT ["ls","-a"][root@docker ceshi]# docker run 3073a603459e
.
..
.dockerenv
bin
dev
etc
home
[root@docker ceshi]# docker run 3073a603459e -l
total 56
drwxr-xr-x 1 root root 4096 Jan 9 13:22 .
drwxr-xr-x 1 root root 4096 Jan 9 13:22 ..
-rwxr-xr-x 1 root root 0 Jan 9 13:22 .dockerenv
lrwxrwxrwx 1 root root 7 Nov 3 2020 bin -> usr/bin
drwxr-xr-x 5 root root 340 Jan 9 13:22 dev
drwxr-xr-x 1 root root 4096 Jan 9 13:22 etcDockerfile命令与Linux相识，需要了解他们的区别
实战：Tomcat镜像
1、准备镜像文件tomcat压缩包，jdk的压缩包
[root@docker tomcat]# ll
total 200808
-rw-r--r-- 1 root root 11582777 Jan 10 19:22 apache-tomcat-9.0.56.tar.gz
-rw-r--r-- 1 root root 194042837 Jan 10 19:06 jdk-8u202-linux-x64.tar.gz2、编写Dockerfile文件，官方文件命名格式
FROM centos
MAINTAINER study<xxxx@xxx.com>
ADD jdk-8u202-linux-x64.tar.gz /usr/local
ADD apache-tomcat-9.0.56.tar.gz /usr/local
RUN yum -y install vim
ENV MYPATH /usr/local
WORKDIR $MYPATH
ENV JAVA_HOME /usr/local/jdk1.8.0_202
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.56
ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.56
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
EXPOSE 8080
CMD /usr/local/apache-tomcat-9.0.56/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.56/bin/logs/catalina.out3、构建镜像
docker build -t diytomcat .4、启动镜像
docker run -d -p 9090:8080 --name studytomcate -v /home/ceshi/build/tomcat/test:/usr/local/usr/local/apache-tomcat-9.0.56/webapps/test -v /home/ceshi/build/tomcat/tomcatlogs:/usr/local/usr/local/apache-tomcat-9.0.56/logs diytomcat5、访问测试
6、发布项目（由于做了卷挂载，可以直接在本地挂载）
/home/ceshi/build/tomcat/test
发布自己镜像
DockerHub
1、地址 https://hub.docker.com/ 注册自己的账户！
2、确定这个账号可以登录
3、在我们的服务器上提交自己的镜像
[root@docker tomcat]# docker login --help
Usage: docker login [OPTIONS] [SERVER]
Log in to a Docker registry.
If no server is specified, the default is defined by the daemon.
Options:
-p, --password string Password
--password-stdin Take the password from stdin
-u, --username string Username
[root@docker tomcat]# docker login -u accout
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 Succeeded4、登录之后就可以提交镜像了、docker push
# push自己的镜像到服务器上！
[root@docker tomcat]# docker push diytomcat
Using default tag: latest
The push refers to repository [docker.io/library/diytomcat]
e87c75160e5c: Preparing
da139022ffa0: Preparing
1102b752dd88: Preparing
74ddd0ec08fa: Preparing
denied: requested access to the resource is denied #拒绝
[root@docker tomcat]# docker tag 4eb27881b42f accout/diytomcat:1.0
[root@docker tomcat]# docker push accout/diytomcat:1.0
The push refers to repository [docker.io/accout/diytomcat]
e87c75160e5c: Pushing [=====================================> ] 50.26MB/66.34MB
da139022ffa0: Pushed
1102b752dd88: Pushing [======> ] 55.92MB/402.5MB
74ddd0ec08fa: Pushing [========> ] 39.87MB/231.3MB阿里云镜像服务上
1、登录阿里云
2、找到容器镜像服务
3、创建命名空间
4、创建容器镜像
5、浏览阿里云
阿里云容器镜像的操作参考官方地址说明
小结
Docker网络
理解Docker0
测试
三个网络
# 问题：docker 是如何处理容器网络访问的？[root@docker tomcat]# docker run -d -P --name tomcat01 tomcat
查看容器的内部网络地址 ip addr
[root@docker tomcat]# docker exec -it tomcat01 ip addr原理
1、我们每启动一个docker容器就好给docker容器分配一个ip地址
结论：tomcat01和Tomact02是公用的一个路由，docker0
所有的容器不指定网络的情况下，都是docker01路由，docker会给我的容器分配一个默认的可用的ip
小结
Docker中的所有的网络接口都是虚拟的，虚拟的转发效率高！！！
只要容器删除，对应网桥，一对就没有了
--link
思考一个场景，我们编写了一个微服务，database url=ip ,项目不重启，数据库ip换掉，我们希望可以出来这个问题，可以用名字来访问容器?
docker run -d -P --name tomcat03 --link tomcat02 tomcat
docker exec -it tomcat03 ping tomcat02其实原理是这个tomcat3在本地hosts配置了tomcat2的解析
[root@docker tomcat]# docker exec -it tomcat03 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 3135d83e6a45
172.17.0.4 003241ea0266真实的玩Docker已经不建议使用 --link 了!
自定义网络
查看所有的docker网络
[root@docker tomcat]# docker network ls
NETWORK ID NAME DRIVER SCOPE
a19e24929bbf bridge bridge local
91beed35ab2a host host local
de830d9523a2 none null local网络模式
bridge ： 桥接 docker
none ：不配置网络
host : 和宿主机共享网络
container : 容器网络连通！（用的少！有局限性）
测试
# 我们直接启动的命令 --net bridge ,而这个就是我们的docker0
docker run -d -P tomcat01 tomcat
docker run -d -P tomcat01 --net bridge tomcat
# docker0 特点，默认，域名不能访问， --link可以打通链接
# 我们可以自定义一个网络！
# --driver bridge
# --subnet 192.168.0.0/16
# --gateway 192.168.0.1
[root@docker tomcat]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
a0230f807e1c1f773b7327b66ba38e25046554a47e5f8ccf9bdc9b022987c733
[root@docker tomcat]# docker network ls
NETWORK ID NAME DRIVER SCOPE
a19e24929bbf bridge bridge local
91beed35ab2a host host local
a0230f807e1c mynet bridge local
de830d9523a2 none null local[root@docker tomcat]# docker run -d -P --name tomcat-net-01 --net mynet tomcat
05bdd0d726ad7c77823a3be8724b4b54e78ac32c92e8fa05495bc42813f27413
[root@docker tomcat]# docker run -d -P --name tomcat-net-02 --net mynet tomcat
d1eff172338128dd491347b19cd591a865269a41cb13252b0cafd4b35e6aea70
[root@docker tomcat]# docker network inspect mynet
[
{
"Name": "mynet",
"Id": "a0230f807e1c1f773b7327b66ba38e25046554a47e5f8ccf9bdc9b022987c733",
"Created": "2022-01-10T22:26:24.912187707+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": {
"05bdd0d726ad7c77823a3be8724b4b54e78ac32c92e8fa05495bc42813f27413": {
"Name": "tomcat-net-01",
"EndpointID": "abedd6adc84f33255730ab187dbd9c2b9daf22ffe167444f8690763e1caff192",
"MacAddress": "02:42:c0:a8:00:02",
"IPv4Address": "192.168.0.2/16",
"IPv6Address": ""
},
"d1eff172338128dd491347b19cd591a865269a41cb13252b0cafd4b35e6aea70": {
"Name": "tomcat-net-02",
"EndpointID": "dfd15807756af56ac931f7b821e636497ba673ac2372965e0e4925cf62e14d81",
"MacAddress": "02:42:c0:a8:00:03",
"IPv4Address": "192.168.0.3/16",
"IPv6Address": ""
}
},
"Options": {},
"Labels": {}
}
]
#再次测试ping链接
[root@docker tomcat]# docker exec -it tomcat-net-01 ping tomcat-net-02我们自定义的网络docker都已经帮我们委会好了对应的关系，推荐我们平时这样使用网络！
好处：
redis-不同的集群使用不同的网络，保证集群是安全和健康的
mysql-不同的集群使用不同的网络，保证集群是安全和健康的
网络连通
docker network --help
docker network connect --help
#测试打通 tomcat01 - mynet
[root@docker tomcat]# docker network connect mynet tomcat01
#连通之后就是将 tomcat01 防止到了 mynet 网络下
# 一个容器两个ip，相当于阿里云的公网ip 和 私网ip
结论：假设要跨网络操作其他机器，就需要使用docker network connect !!!
实战：部署Redis集群
shell脚本！
# 创建网卡
docker network create redis --subnet 172.38.0.0/16
#通过脚本创建6个redis配置
for port in $(seq 1 6); \
do \
mkdir -p /data/redis/node-${port}/conf
touch /data/redis/node-${port}/conf/redis.conf
cat << EOF >/data/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
# 批量启动
for port in $(seq 1 6); \
do \
docker run -p 637${port}:6379 -p 1637${port}:16379 --name redis-${port} \
-v /data/redis/node-${port}/data:/data \
-v /data/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
done
#进入redis-1的容器
[root@docker data]docker exec -it redis-1 /bin/sh
# 启动集群
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-r
eplicas 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: 275c12efbdc7a0141da8cf452fb4ffee81d9f225 172.38.0.11:6379
slots:[0-5460] (5461 slots) master
M: d2fa650c7610206c4f46a50cc499a0d65627fb31 172.38.0.12:6379
slots:[5461-10922] (5462 slots) master
M: 56276477a16913f4ebb760d0c930c9674853869b 172.38.0.13:6379
slots:[10923-16383] (5461 slots) master
S: 00cef341362c363e9f3e1f17871747d197b5e69a 172.38.0.14:6379
replicates 56276477a16913f4ebb760d0c930c9674853869b
S: 7455315e093a57fa16c90003a3b864e2ece8773c 172.38.0.15:6379
replicates 275c12efbdc7a0141da8cf452fb4ffee81d9f225
S: c6c0a6bcb195029b5b1b20b507b21270b58eda69 172.38.0.16:6379
replicates d2fa650c7610206c4f46a50cc499a0d65627fb31
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: 275c12efbdc7a0141da8cf452fb4ffee81d9f225 172.38.0.11:6379
slots:[0-5460] (5461 slots) master
1 additional replica(s)
S: 7455315e093a57fa16c90003a3b864e2ece8773c 172.38.0.15:6379
slots: (0 slots) slave
replicates 275c12efbdc7a0141da8cf452fb4ffee81d9f225
S: c6c0a6bcb195029b5b1b20b507b21270b58eda69 172.38.0.16:6379
slots: (0 slots) slave
replicates d2fa650c7610206c4f46a50cc499a0d65627fb31
M: 56276477a16913f4ebb760d0c930c9674853869b 172.38.0.13:6379
slots:[10923-16383] (5461 slots) master
1 additional replica(s)
S: 00cef341362c363e9f3e1f17871747d197b5e69a 172.38.0.14:6379
slots: (0 slots) slave
replicates 56276477a16913f4ebb760d0c930c9674853869b
M: d2fa650c7610206c4f46a50cc499a0d65627fb31 172.38.0.12:6379
slots:[5461-10922] (5462 slots) master
1 additional replica(s)
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
#进入redis
redis-cli -c
#查看集群信息
cluster info
#查看节点信息
cluster nodesdocker搭建redis集群完成！
我们使用docker之后，所有技术都会慢慢变得简单。redis集群搭建就是这么简单。
SpringBoot微服务打包Docker镜像
1、构建springboot项目
2、打包应用
3、编写Dockerfile
4、构建镜像
5、发布运行！
1、创建一个SpringBoot的hello world项目打包一个jar包
2、编写Dockerfile文件
FROM java:8
COPY *.jar /app.jar
CMD ["--server.port=8080"]
EXPOSE 8080
ENTRYPOINT ["java","-jar","/app.jar"]
3、发布镜像 docker build -t study
4、随机指定端口运行 docker run -d -P --name study-web studyDocker Compose
简介
Compose 是用于定义和运行多容器 Docker 应用程序的管理工具。通过 Compose，您可以使用 YML 文件来配置应用程序需要的所有服务。然后，使用一个命令，就可以从 YML 文件配置中创建并启动所有服务。【只能够管理单台主机-需要管理多台主机使用Kubernetes，一般企业使用的是的Kubernetes】
Compose 使用的三个步骤：
使用 Dockerfile 定义应用程序的环境。
使用 docker-compose.yml 定义构成应用程序的服务，这样它们可以在隔离环境中一起运行。
最后，执行 docker-compose up 命令来启动并运行整个应用程序。
作用：批量容器编排
理解简介
一个web服务涉及到多个容器：redis、mysql、nginx... 多个关联的容器，这些容器组建了一个完整的web服务。不可能每个都要启动。就需要编排一起启动
# yaml 配置实例
version: '3'
services:
web:
build: .
ports:
- "5000:5000"
volumes:
- .:/code
- logvolume01:/var/log
links:
- redis
redis:
image: redis
volumes:
logvolume01: {}安装
1、下载
# 官方地址
curl -L https://github.com/docker/compose/releases/download/v2.2.3/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose
# 备用地址
curl -L https://get.daocloud.io/docker/compose/releases/download/v2.2.3/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
# 赋予脚本可执行权限
chmod +x /usr/local/bin/docker-compose体验
参考：https://www.runoob.com/docker/docker-compose.html 使用准备
yaml编写规则
docker-compose.yaml
#3层
version: '' #版本
services: #服务
服务1: web
#服务配置
images
build
network
depends_on #依赖下面的容器先起来
- redis
- mysql
.....
服务2: redis
....
服务3: mysql
#其他配置 网络/卷、全局规则
volume:
network:
configs:官方文档：https://docs.docker.com/compose/compose-file/
源项目
博客搭建：https://docs.docker.com/samples/wordpress/
1、下载项目 docker-compose.yml
2、如果需要文件 Dockerfile
3、文件准备齐全（直接一键启动项目！）
实战
1、编写项目微服务
2、dockerfile构建镜像
3、docker-compose.yml编排项目
4、丢到服务器里面 docker-compose up -d
# Dockerfile文件
FROM java:8
COPY *.jar /app.jar
CMD ["--server.port=8080"]
EXPOSE 8080
ENTRYPOINT ["java","-jar","/app.jar"]
#docker-compose.yml文件
version: "2.2"
services:
studyapp:
build: .
depends_on:
- redis
ports:
- "8080:8080"
redis:
image: "library/redis:alpine"将写的demo.jar、Dockerfile、docker-compose.yml丢到服务器。运行 docker-compose up
Kubernetes
简介
Kubernetes 是 Google 团队发起的开源项目，它的目标是管理跨多个主机的容器，提供基本的部署，维护以及应用伸缩，主要实现语言为 Go 语言。Kubernetes 是：
易学：轻量级，简单，容易理解
便携：支持公有云，私有云，混合云，以及多种云平台
可拓展：模块化，可插拔，支持钩子，可任意组合
自修复：自动重调度，自动重启，自动复制
Kubernetes 构建于 Google 数十年经验，一大半来源于 Google 生产环境规模的经验。结合了社区最佳的想法和实践。
在分布式系统中，部署，调度，伸缩一直是最为重要的也最为基础的功能。Kubernetes 就是希望解决这一序列问题的。
Kubernetes 目前在GitHub进行维护。
基本概念
节点（Node）：一个节点是一个运行 Kubernetes 中的主机。
容器组（Pod）：一个 Pod 对应于由若干容器组成的一个容器组，同个组内的容器共享一个存储卷(volume)。
容器组生命周期（pos-states）：包含所有容器状态集合，包括容器组状态类型，容器组生命周期，事件，重启策略，以及 replication controllers。
Replication Controllers：主要负责指定数量的 pod 在同一时间一起运行。
服务（services）：一个 Kubernetes 服务是容器组逻辑的高级抽象，同时也对外提供访问容器组的策略。
卷（volumes）：一个卷就是一个目录，容器对其有访问权限。
标签（labels）：标签是用来连接一组对象的，比如容器组。标签可以被用来组织和选择子对象。
接口权限（accessing_the_api）：端口，IP 地址和代理的防火墙规则。
web 界面（ux）：用户可以通过 web 界面操作 Kubernetes。
命令行操作（cli）：kubectl命令。
安装部署
参考：https://blog.csdn.net/qq_27706119/article/details/114015730
1、准备3台主机
192.168.1.101 master
192.168.1.102 node-1
192.168.1.103 node-2
测试要求：
master 2H4G 20G node 4H8G 40G
生产环境：
master 4H8G 40G node 8H16G 80G
所有机器关闭防火墙
systemctl disable firewalld2、所有机器安装docker。请查看docker的安装
yum install -y yum-utils
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
yum install docker-ce docker-ce-cli containerd.io
systemctl enable docker && systemctl start docker3、在master主机添加hosts
cat >> /etc/hosts <<EOF
192.168.1.101 k8s-master
192.168.1.102 k8s-node-1
192.168.1.103 k8s-node-2
EOF4、所有主机添加yum源，并且安装 kubelet kubeadm kubectl
#CentOS安装
#1、添加kubernetes的yum源
cat <<EOF | tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF
#2、yum安装 kubelet kubeadm kubectl
yum install -y kubelet kubeadm kubectl
systemctl enable kubelet
#3、修改内核的运行参数
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
br_netfilter
EOF
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
sudo sysctl --system部署Kubernetes Master
在 192.168.1.101 （master ）执行
#查看版本
kubelet --version
# --apiserver-advertise-address可不用默认是将自动检测网络接口
kubeadm init \
--apiserver-advertise-address=192.168.1.101 \
--image-repository registry.cn-hangzhou.aliyuncs.com/google_containers \
--kubernetes-version v1.23.1 \
--service-cidr=10.96.0.0/12 \
--pod-network-cidr=10.244.0.0/16执行成功之后新开一个shell查看docker images 会有很多镜像
执行错误：(内核版本过低至少大于3.10)
内核升级：https://www.cnblogs.com/xzkzzz/p/9627658.html
[root@k8s-master ~]# uname -r
3.10.0-327.4.5.el7.x86_64
错误提示：curl -sSL http://localhost:10248/healthz‘ failed with error:
#关闭swap交换
swapoff -a
#重启kubelet服务
systemctl restart kubelet
#重置K8S配置
kubeadm reset
#删除配置文件
rm -rf $HOME/.kube/config 执行成功之后会提示如下操作
加入到Kubernetes Node
在192.168.1.102 （node）执行
向集群添加新的节点，之偶像kubuadm init输出的kubeadm join命令：
kubeadm join 192.168.1.101:6443 --token xxxxxxxx \
--discovery-token-ca-cert-hash
3908
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
