提纲：Docker和Kubernetes关系
本人开始今天分享之前想提以前简单的问题，大家可以试试回答。Kubernetes和Docker关系？
Kubernetes的作用是管理容器,docker一旦变多,重启,容器通信等一系列过程就需要一个工具来进行管理,这就是Kubernetes做的事情
K8S 调度的基本单位为 pod（一个POD表示一个或多个容器），为什么基本单位不是一个容器？
Docker概述
Docker是什么?
? Docker 是一个开源项目，诞生于 2013 年初，最初是 dotCloud 公司内部的一个业余项目。它基于 Google 公司推出的Go语言实现。项目后来加入了 Linux 基金会，遵从了 Apache 2.0 协议，项目代码在GitHub 上进行维护。
? Docker 项目的目标是实现轻量级的操作系统虚拟化解决方案。Docker 的基础是 Linux 容器（LXC）等技术，在 LXC 的基础上 Docker 进行了进一步的封装，让用户不需要去关心容器的管理，使得操作更为简便。用户操作 Docker 的容器就像操作一个快速轻量级的虚拟机一样简单。
既然是都是虚拟化技术， 为什么不直接使用虚拟机？
| 序号 | Docker | 虚拟机 |
|---|---|---|
| 1 | 占用资源少 | 资源占用多 |
| 2 | 操作简单 | 冗余步骤多 |
| 3 | 启动快 | 启动慢 |
备注：区分容器和虚拟机概念（容器起源自Linux Containers（LXC）一种新的虚拟化技术）
-
容器内应用进程直接运行于宿主内核是对进程进行隔离的技术、包含完整文件系统，并区分计算资源、自身无内核、无需硬件虚拟。
-
虚拟机在虚拟出一套硬件后在其基础上搭建套操作系统，后运行软件。
（补充）为什么Docker比较 VM 快?
1、docker有着比虚拟机更少的抽象层。由亍docker不需要Hypervisor实现硬件资源虚拟化,运行在docker容器上的程序直接使用的都是实际物理机的硬件资源。因此在CPU、内存利用率上docker将会在效率上有明显优势。
2 、docker利用的是宿主机的内核,而不需要Guest OS。因此,当新建一个容器时,docker不需要和虚拟机一样重新加载一个操作系统内核。仍而避免引寻、加载操作系统内核返个比较费时费资源的过程,当新建一个虚拟机时,虚拟机软件需要加载Guest OS,返个新建过程是分钟级别的。而docker由于直接利用宿主机的操作系统,则省略了返个过程,因此新建一个docker容器只需要几秒钟。
容器化技术给开发/运维（DevOps）/部署能带来哪些便捷？
| 序号 | 维度 | Docker开发/运维 | 传统开发/运维 |
|---|---|---|---|
| 1 | 应用交付和部署 | 少量容器镜像文件（配置文件内置） | 复杂的安装程序和配置说明文档 |
| 2 | 升级、迁移、扩缩容 | 通过镜像运行新的容器进行快速扩容 | 重新部署上线 |
| 3 | 系统运维 | 生产、开发、测试环境高度一致； 配置文件封装； 测试快速定位、修复； 更快速的交付和部署； 更简单的管理； 更快速的启动时间 | 生产、开发、测试环境高不一致； 管理、交付、部署难度大； 虚拟机启动时间慢 |
| 4 | 资源利用 | 内核级虚拟化； 一台物理机上可以运行很多个容器实例； 提升物理服务器的CPU和内存的利用率； | 传统的虚拟化技术需要额外Hypervisor |
Docker是怎么工作的？
Docker是一个Client-Server结构的系统，Docker守护进程运行在主机上， 然后通过Socket连接从客户端访问，守护进程从客户端接受命令并管理运行在主机上的容器。 容器，是一个运行时环境，就是我们 前面说到的集装箱。
备注：
- Docker官网：http://www.docker.com
- Docker中文网站：https://www.docker-cn.com
- Docker Hub官网：https://hub.docker.com （仓库）
?
Docker安装
Docker组成
备注：区分镜像和容器
-
镜像（image）：Docker 镜像（Image）就是一个只读的模板。镜像可以用来创建 Docker 容器，一个镜像可以创建很多容器。 就好似 Java 中的 类和对象，类就是镜像，容器就是对象！
-
容器（container）：Docker 利用容器(Container)独立运行的一个或一组应用。容器是用镜像创建的运行实例。 它可以被启动、开始、停止、删除。每个容器都是相互隔离的，保证安全的平台。可以把容器看做是一个简易版的 Linux 环境(包括root用户权限、进程空间、用户空间和网络空间等) 和运行在其中的应用程序。
-
仓库（repository）：仓库(Repository)是集中存放镜像文件的场所。 仓库(Repository)和仓库注册服务器(Registry)是有区别的。仓库注册服务器上往往存放着多个仓库，每个仓库中又包含了多个镜像，每个镜像有不同的标签(tag)。 仓库分为公开仓库(Public)和私有仓库(Private)两种形式。最大的公开仓库是 Docker Hub(https://hub.docker.com/)，存放了数量庞大的镜像供用户下载。 国内的公开仓库包括阿里云 、网易云等
补充：容器的定义和镜像几乎一模一样，也是一堆层的统一视角，唯一区别在于容器的最上面那一层是可读可写的。
Docker安装
官网安装参考手册：https://docs.docker.com/engine/install/centos/
1、yum安装gcc相关环境（需要确保 虚拟机可以上外网 ）
yum -y install gcc
yum -y install gcc-c++
2 、卸载旧版本
yum remove docker \
docker-client \
docker-client-latest \
docker-common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \
docker-engine
3、安装需要的YUM软件包
yum install -y yum-utils
4、设置镜像仓库
# 正确推荐使用国内的
yum-config-manager --add-repo http://mirrors.aliyun.com/docker- ce/linux/centos/docker-ce.repo
5、更新yum软件包索引
yum makecache fast
6、安装 Docker CE
yum install docker-ce docker-ce-cli containerd.io
7、启动Docker
systemctl start docker
8、卸载Docker
systemctl stop docker
yum -y remove docker-ce docker-ce-cli containerd.io
rm -rf /var/lib/docker
Docker常用命令
基本命令
docker version # 显示 Docker 版本信息。
docker info # 显示 Docker 系统信息，包括镜像和容器数。。
docker --help # 帮助
docker images # 列出本地主机上的镜像
# 备注：同一个仓库源可以有多个 TAG，代表这个仓库源的不同版本，我们使用REPOSITORY:TAG 定义不同 的镜像，如果你不定义镜像的标签版本，docker将默认使用 lastest 镜像!
docker search mysql # 搜索镜像
docker pull mysql/mysql：8.0 # 下载镜像
docker pull centos # 下载容器
docker rmi -f 镜像id # 删除单个
docker rmi -f 镜像名:tag 镜像名:tag # 删除多个
docker rmi -f $(docker images -qa) # 删除全部
docker run -it centos /bin/bash # 新建容器并启动
docker ps # 列出所有运行的容器
docker start (容器id or 容器名) # 启动容器
docker restart (容器id or 容器名) # 重启容器
docker stop (容器id or 容器名) # 停止容器
docker kill (容器id or 容器名) # 强制停止容器
docker rm 容器id # 删除指定容器
docker rm -f $(docker ps -a -q) # 删除所有容器
docker ps -a -q|xargs docker rm # 删除所有容器
# 从容器内拷贝文件到主机上
docker cp 容器id:容器内路径 目的主机路径
docker commit 提交容器副本使之成为一个新的镜像！
# 语法
docker commit -m="提交的描述信息" -a="作者" 容器id 要创建的目标镜像名:[标签名]
# 例子
docker run -d centos # 启动centos，使用后台方式启动
docker inspect 容器id
# 语法：
# -d 后台运行
# -p 端口
# -v 容器数据卷
# -i 以交互模式运行容器，通常与 -t 同时使用
# -t 为容器重新分配一个伪输入终端，通常与 -i 同时使用
# -d 后台运行容器，并返回容器ID
# -itd 组合命
# 容器进入：
docker exec -it --user root docker-nginx /bin/bash
# 文件向容器复制：
# 语法：docker cp 容器外路径 容器ID:容器内路径
docker cp 外部文件地址 e7f25fc3bd48:容器内文件地址
# Nginx：
docker run -d -p 80:80 -v 外部文件地:容器内文件地址 --name docker-nginx nginx
# MySQL：
docker run -d -p 3306:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name docker-mysql mysql:8.0
# Redis：
docker run -itd --name docker-redis -p 6379:6379 redis
# RabbitMQ：
docker pull rabbitmq
docker pull rabbitmq:management
docker run -d --name docker-rabbitmq -p 5671:5671 -p 5672:5672 -p 4369:4369 -p 25672:25672 -p 15671:15671 -p 15672:15672 rabbitmq:management
练习：
docker search nginx
docker pull nginx
docker images
docker run -d --name mynginx -p 3500:80 nginx
docker ps
curl localhost:3500
docker exec -it mynginx /bin/bash
whereis nginx # 寻找nginx
cd /usr/share/nginx # nginx 的路径
vim index.html #修改index
可视化/管理工具
Portainer
docker run -d -p 8088:9000 \
--restart=always -v /var/run/docker.sock:/var/run/docker.sock --
privileged=true portainer/portainer
Portainer是Docker的图形化管理工具，提供状态显示面板、应用模板快速部署、容器镜像网络数据卷的基本操作（包括上传下载镜像，创建容器等操作）、事件日志显示、容器控制台操作、Swarm集群和服务等集中管理和操作、登录用户管理和控制等功能。功能十分全面，面向中小型单位对容器管理的全部需求。
访问方式：http://IP:8088
首次登陆需要注册用户，给admin用户设置密码：单机版这里选择local即可，选择完毕，点击Connect即可连接到本地docker：
Docker Dasktop
Docker镜像原理
镜像是什么？
镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含运行某个软件所需的所有内容，包括代码、运行时、库、环境变量和配置文件。
Docker镜像加载原理
在聊这个话题时候需要提前了解两个知识点，什么是UnionFS ？有兴趣可以去了解一下，这里只做简单阐述。
? UnionFS（联合文件系统）：Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。Union 文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。
特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录
UnionFS和Docker镜像加载原理有什么关系？
docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS。bootfs(boot file system)主要包含bootloader和kernel, bootloader主要是引导加载kernel, Linux刚启动时会加载bootfs文件系统，在Docker镜像的最底层是bootfs。这一层与我们典型的Linux/Unix系统是一样的，包含boot加载器和内核。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。bootfs (root file system) ，在bootfs之上。包含的就是典型 Linux 系统中的 /dev, /proc, /bin, /etc 等标准目录和文件。rootfs就是各种不同的操作系统发行版，比如Ubuntu，Centos等等。
平时我们安装进虚拟机的CentOS都是好几个G，为什么Docker这里才200M？
对于一个精简的OS，rootfs 可以很小，只需要包含最基本的命令，工具和程序库就可以了，因为底层直接用Host的kernel，自己只需要提供rootfs就可以了。由此可见对于不同的linux发行版, bootfs基本是一致的, rootfs会有差别, 因此不同的发行版可以公用bootfs。
备注： Linuxkernel是一个一体化内核（monolithic kernel）系统，提供硬件抽象层、磁盘及文件系统控制、多任务等功能的系统软件，不是一套完整的操作系统。有兴趣可以去阅读： Linux内核的工作原理
Docker文件分层原理
分层的镜像：我们可以去下载一个镜像，注意观察下载的日志输出，可以看到是一层一层的在下载！
为什么Docker镜像要采用这种分层的结构呢？
最大的好处，我觉得莫过于是资源共享了！比如有多个镜像都从相同的Base镜像构建而来，那么宿主机只需在磁盘上保留一份base镜像，同时内存中也只需要加载一份base镜像，这样就可以为所有的容器服务了，而且镜像的每一层都可以被共享。
备注：查看镜像分层的方式可以通过 docker image inspect 命令！
拓展：所有的 Docker 镜像都起始于一个基础镜像层，当进行修改或增加新的内容时，就会在当前镜像层上，创建新的镜像层。举一个简单的例子，假如基于 Ubuntu Linux 16.04 创建一个新的镜像，这就是新镜像的第一层；如果在该镜像中添加 Python包，就会在基础镜像层之上创建第二个镜像层；如果继续添加一个安全补丁，就会创建第三个镜像层。该镜像当前已经包含 3 个镜像层，如下图所示（这只是一个用于演示的很简单的例子）。
在添加额外的镜像层的同时，镜像始终保持是当前所有镜像的组合，理解这一点非常重要。下图中举了一个简单的例子，每个镜像层包含 3 个文件，而镜像包含了来自两个镜像层的 6 个文件。
上图中的镜像层跟之前图中的略有区别，主要目的是便于展示文件。下图中展示了一个稍微复杂的三层镜像，在外部看来整个镜像只有 6 个文件，这是因为最上层中的文件7 是文件 5 的一个更新版本。这种情况下，上层镜像层中的文件覆盖了底层镜像层中的文件。这样就使得文件的更新版本作为一个新镜像层添加到镜像当中。
Docker 通过存储引擎（新版本采用快照机制）的方式来实现镜像层堆栈，并保证多镜像层对外展示为统一的文件系统。
Linux 上可用的存储引擎有 AUFS、Overlay2、Device Mapper、Btrfs 以及 ZFS。顾名思义，每种存储引擎都基于 Linux 中对应的文件系统或者块设备技术，并且每种存储引擎都有其独有的性能特点。
Docker 在 Windows 上仅支持 windowsfilter 一种存储引擎，该引擎基于 NTFS 文件系统之上实现了分层和 CoW[1]。下图展示了与系统显示相同的三层镜像。所有镜像层堆叠并合并，对外提供统一的视图。
![(img-GW34mpWa-1634551438154)(https://i.loli.net/2021/08/30/NVgljJnYWadeCqD.png)]https://i.loli.net/2021/08/30/NVgljJnYWadeCqD.png](https://img-blog.csdnimg.cn/f45439d5ffc44bb5abadd94c42482b75.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA56Gs5rC05p6c57OW,size_20,color_FFFFFF,t_70,g_se,x_16)
特点：Docker镜像都是只读的，当容器启动时，一个新的可写层被加载到镜像的顶部！这一层就是我们通常说的容器层，容器之下的都叫镜像层！
Docker数据持久
容器数据卷
什么是容器数据卷，为什么要用容器数据卷？
将应用和运行的环境打包形成容器运行，运行可以伴随着容器，但是我们对于数据的要求，是希望能够持久化的！就好比，你安装一个MySQL，结果你把容器删了，就相当于删库跑路了，这TM也太扯了吧！所以我们希望容器之间有可能可以共享数据，Docker容器产生的数据，如果不通过docker commit 生成新的镜像，使得数据作为镜像的一部分保存下来，那么当容器删除后，数据自然也就没有了！这样是行不通的！为了能保存数据在Docker中我们就可以使用卷！让数据挂载到我们本地！这样数据就不会因为容器删除而丢失了！
容器数据卷作用是什么？
卷就是目录或者文件，存在一个或者多个容器中，由docker挂载到容器，但不属于联合文件系统，因此能够绕过 Union File System ， 提供一些用于持续存储或共享数据的特性：卷的设计目的就是数据的持久化，完全独立于容器的生存周期，因此Docker不会在容器删除时删除其挂载的数据卷。
容器数据卷特点?
- 数据卷可在容器之间共享或重用数据
- 卷中的更改可以直接生效
- 数据卷中的更改不会包含在镜像的更新中
- 数据卷的生命周期一直持续到没有容器使用它为止
备注：总结一句话： 就是容器的持久化，以及容器间的继承和数据共享！
容器数据卷如何使用？
docker run -it -v 宿主机绝对路径目录:容器内目录 镜像名
# 测试
[root@kuangshen ~]# docker run -it -v /home/ceshi:/home centos /bin/bash
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-f8SWyTLg-1634551438155)(https://i.loli.net/2021/08/30/qnVfBJiOzKskuav.png)]
容器挂载
mysql 数据持久化的问题！
# 1、搜索镜像
[root@kuangshen ~]# docker search mysql
NAME DESCRIPTION
STARS
mysql MySQL is a widely used, open-source
relation... 9488
# 2、拉取镜像
[root@kuangshen ~]# docker pull mysql:5.7
5 .7: Pulling from library/mysql
54fec2fa59d0: Already exists
bcc6c6145912: Pull complete
951c3d959c9d: Pull complete
05de4d0e206e: Pull complete
319f0394ef42: Pull complete
d9185034607b: Pull complete
013a9c64dadc: Pull complete
e745b3361626: Pull complete
03145d87b451: Pull complete
3991a6b182ee: Pull complete
62335de06f7d: Pull complete
Digest:
sha256:e821ca8cc7a44d354486f30c6a193ec6b70a4eed8c8362aeede4e9b8d74b8ebb
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7
# 3、启动容器 -e 环境变量！
# 注意： mysql的数据应该不丢失！先体验下 -v 挂载卷！ 参考官方文档
[root@kuangshen 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
4763fa5c68c4323688102f57938fb10996a0fb902d2812349286529f9378f16c
# 4、使用本地的sqlyog连接测试一下 3310
# 5、查看本地的 /home/mysql 目录 [root@kuangshen data]# pwd /home/mysql/data [root@kuangshen data]# ls
.. ... . test # 可以看到我们刚刚建立的mysql数据库在本地存储着
# 6、删除mysql容器
[root@kuangshen data]# docker rm -f mysql01 # 删除容器，然后发现远程连接失败! mysql01
[root@kuangshen data]# ls
.. ... . test # 可以看到我们刚刚建立的mysql数据库在本地存储着
匿/具名挂载
什么是匿名和具名挂载？
# 匿名挂载
-v 容器内路径
docker run -d -P --name nginx01 -v /etc/nginx nginx
# 匿名挂载的缺点，就是不好维护，通常使用命令 docker volume维护 docker volume ls
# 具名挂载
-v 卷名:/容器内路径
docker run -d -P --name nginx02 -v nginxconfig:/etc/nginx nginx
# 查看挂载的路径
[root@kuangshen ~]# docker volume inspect nginxconfig [
{
"CreatedAt": "2020-05-13T17:23:00+08:00",
"Driver": "local",
"Labels": null,
"Mountpoint": "/var/lib/docker/volumes/nginxconfig/_data",
"Name": "nginxconfig",
"Options": null,
"Scope": "local"
} ]
# 怎么判断挂载的是卷名而不是本机目录名? 不是/开始就是卷名，是/开始就是目录名
# 改变文件的读写权限
# ro: readonly
# rw: readwrite
# 指定容器对我们挂载出来的内容的读写权限
docker run -d -P --name nginx02 -v nginxconfig:/etc/nginx:ro nginx docker run -d -P --name nginx02 -v nginxconfig:/etc/nginx:rw nginx
Docker File
DockerFile 是用来构建Docker镜像的构建文件，是由一些列命令和参数构成的脚本。我们在这里，先体验下，后面我们会详细讲解 DockerFile ！
测试：
# 1、我们在宿主机 /home 目录下新建一个 docker-test-volume文件夹
[root@kuangshen home]# mkdir docker-test-volume
# 说明:在编写DockerFile文件中使用 VOLUME 指令来给镜像添加一个或多个数据卷
VOLUME["/dataVolumeContainer1","/dataVolumeContainer2","/dataVolumeContainer 3"]
# 出于可移植和分享的考虑，我们之前使用的 -v 主机目录:容器目录 这种方式不能够直接在 DockerFile中实现。
# 由于宿主机目录是依赖于特定宿主机的，并不能够保证在所有宿主机上都存在这样的特定目录.
# 2、编写DockerFile文件
[root@kuangshen docker-test-volume]# pwd /home/docker-test-volume
[root@kuangshen docker-test-volume]# vim dockerfile1 [root@kuangshen docker-test-volume]# cat dockerfile1
# volume test
FROM centos
VOLUME ["/dataVolumeContainer1","/dataVolumeContainer2"] CMD echo "-------end------"
CMD /bin/bash
# 3、build后生成镜像，获得一个新镜像 kuangshen/centos
docker build -f /home/docker-test-volume/dockerfile1 -t kuangshen/centos . # 注意最后有个.
# 4、启动容器
[root@kuangshen docker-test-volume]# docker run -it 0e97e1891a3d /bin/bash # 启动容器
[root@f5824970eefc /]# ls -l
total 56
# 问题:通过上述步骤，容器内的卷目录地址就已经知道了，但是对应的主机目录地址在哪里呢?
# 5、我们在数据卷中新建一个文件
[root@f5824970eefc dataVolumeContainer1]# pwd /dataVolumeContainer1
[root@f5824970eefc dataVolumeContainer1]# touch container.txt [root@f5824970eefc dataVolumeContainer1]# ls -l
total 0
-rw-r--r-- 1 root root 0 May 11 11:58 container.txt
# 6、查看下这个容器的信息
[root@kuangshen ~]# docker inspect 0e97e1891a3d # 查看输出的Volumes
"Volumes": {
"/dataVolumeContainer1": {},
"/dataVolumeContainer2": {}
},
# 7、这个卷在主机对应的默认位置
# 注意:如果访问出现了 cannot open directory: Permission denied 解决办法:在挂载目录后多加一个 --privileged=true参数即可
数据卷容器
有人会问数据卷容器和容器数据卷有什么区别？
? 它们都是一种同步、持久化技术。容器数据卷是为了防止删除容器的时候数据丢失，构建起镜像和外部文件系统同步机制；数据卷容器是其他的容器通过挂载这个父容器实现数据共享，挂载数据卷的容器，是容器之间数据共享同步机制（类似于单项目集群思想）。
数据卷容器如何使用？
我们使用上一步的镜像：kuangshen/centos 为模板，运行容器 docker01，docker02，docker03，他们都会具有容器卷，我们来测试下，容器间传递共享
docker run -it - -name parentContainer 镜像名 #建立父容器
#语法：--volumes-from
docker run -it - -name sonContainer1 --volumes -from parentContainer 镜像名
docker run -it - -name sonContainer2 --volumes -from parentContainer 镜像名
结论：容器之间配置信息的传递，数据卷的生命周期一直持续到没有容器使用它为止。存储在本机的文件则会一直保留！
DockerFile
DockerFile基础
大家想想，Nginx，tomcat，mysql 这些镜像都是哪里来的？官方能写，我们不能写吗？如何实现自己的docker镜像，么就需要用到DockerFile
-
微服务单体springboot应用打包成镜像（包含数据库、APP、消息队列…）
-
流程：开发应用=>DockerFile=>打包为镜像=>上传到仓库（私有仓库，公有仓库）=> 下载镜像 => 启动
什么是DockerFile?
DockerFile是用来构建Docker镜像的构建文件，是由一系列命令和参数构成的脚本。
如何实现一个dockerFile？
基础知识：
FROM # 基础镜像，当前新镜像是基于哪个镜像的 MAINTAINER # 镜像维护者的姓名混合邮箱地址
RUN # 容器构建时需要运行的命令
EXPOSE # 当前容器对外保留出的端口
WORKDIR # 指定在创建容器后，终端默认登录的进来工作目录，一个落脚点
ENV # 用来在构建镜像过程中设置环境变量
ADD # 将宿主机目录下的文件拷贝进镜像且ADD命令会自动处理URL和解压tar压缩包 COPY # 类似ADD，拷贝文件和目录到镜像中!
VOLUME # 容器数据卷，用于数据保存和持久化工作
CMD # 指定一个容器启动时要运行的命令，dockerFile中可以有多个CMD指令，但只有最 后一个生效!
ENTRYPOINT # 指定一个容器启动时要运行的命令!和CMD一样
ONBUILD # 当构建一个被继承的DockerFile时运行命令，父镜像在被子镜像继承后，父镜像的 ONBUILD被触发
DockerFile测试
建构步骤：编写DockerFile文件>docker build 构建镜像>docker run
例子地址：https://hub.docker.com/_/centos
创建app.py
#ipython
#ipython os
#mkdir python_app
#cd python_app
#vim app.py：
from flask import Flask #from模块调用
import socket #为了获取主机名称用
import os #获取环境变量用的
app = Flask(__name__)
@app.route('/')
def hello():
html = "Hello {name} Hostname: {hostname} This is Dockerfile Demo"
return html.format(name=os.getenv("NAME", "world"), hostname=socket.gethostname())
if __name__ == "__main__": #主函数
app.run(host='0.0.0.0', port=80) #监控本地所有的网卡、监控80端口
创建requirements.txt
Flask
创建Dockerfile
FROM python:3.7-alpine
WORKDIR /app
ADD . /app
RUN pip install --trusted-host pypi.python.org -r requirements.txt
# 使用 pip 命令安装这个应用所需要的依赖
EXPOSE 80
# 允许外界访问容器的 80 端口
ENV NAME World
# 设置环境变量
CMD ["python", "app.py"]
DockerFile拓展
除上述的功能点以外Dockerfile还提供了HEALTHCHECK（状态服务监控）、ENV/ARG（环境配置）、ENTRYPOINT（入口指令）等功能，有兴趣的小伙伴可以去研究一下。
Docker Compose
什么是Docker Compose？
? Compose 是用于定义和运行多容器 Docker 应用程序的工具。通过 Compose，您可以使用 **YML **文件来配置应用程序需要的所有服务。然后，使用一个命令，就可以从 YML 文件配置中创建并启动所有服务。
Docker Compose安装
安装地址：https://docs.docker.com/compose/install/
sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
#备注：要安装其他版本的 Compose，请替换 1.24.1。
# 将可执行权限应用于二进制文件：
sudo chmod +x /usr/local/bin/docker-compose
# 创建软链：
sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose
# 测试是否安装成功：
docker-compose --version
#输出：cker-compose version 1.24.1, build 4667896b
# 卸载
sudo rm /usr/local/bin/docker-compose
pip uninstall docker-compose
Docker Compose测试
mkdir composetest
cd composetest
建一个py.app文件
import time
import redis
from flask import Flask
app = Flask(__name__)
cache = redis.Redis(host='redis', port=6379)
def get_hit_count():
retries = 5
while True:
try:
return cache.incr('hits')
except redis.exceptions.ConnectionError as exc:
if retries == 0:
raise exc
retries -= 1
time.sleep(0.5)
@app.route('/')
def hello():
count = get_hit_count()
return 'Hello World! I have been seen {} times.\n'.format(count)
if __name__ == "__main__":
app.run(host="0.0.0.0", debug=True)
创建一个txt文件requirements.txt
flask
redis
创建一个Dockerfile
FROM python:3.4-alpine
ADD . /code
WORKDIR /code
RUN pip install -r requirements.txt
CMD ["python", "app.py"]
创建 docker-compose.yml
# yaml 配置
version: '3'
services:
web:
build: .
ports:
- "8848:8848"
redis:
image: "redis:alpine"
项目构建
# 启动应用程序：
docker-compose up
#后台执行该服务可以加上 -d 参数：
docker-compose up -d
Docker Compose拓展
除了上面常见的配置，Docker Compose yaml 配置还提供了 endpoint_mode（集群模式vip和轮询机制dnsrr）、healthcheck、logging、network_mode、restart、secrets（存储敏感数据）、devices、dns、env_file、extra_hosts（主机映射）…等等，大家有兴趣的可以去研究一下。
Docker 网络讲解
Docker容器互联
Docker0（IP）
问题：什么是Docker0？
? Docker启动的时候会在主机上自动创建一个docker0网桥，实际上是一个Linux网桥，所有容器的启动如果在docker run的时候没有指定网络模式的情况下都会挂载到docker0网桥上。这样容器就可以和主机甚至是其他容器之间通讯了。
docker network ls # Docker网络（bridge:桥接模式 host:主机模式 none:无网络模式）
docker rm -f $(docker ps -a -q) # 删除所有容器
docker rmi -f $(docker images -qa) # 删除全部镜像
问题：Docker 是如何处理容器网络访问的？
每一个安装了Docker的linux主机都有一个docker0的虚拟网卡。这是个桥接网卡，使用了veth-pair技术！
小结：
Docker使用Linux桥接，在宿主机虚拟一个Docker容器网桥(docker0)，Docker启动一个容器时会根据Docker网桥的网段分配给容器一个IP地址，称为Container-IP，同时Docker网桥是每个容器的默认网关。因为在同一宿主机内的容器都接入同一个网桥，这样容器之间就能够通过容器的Container-IP直接通信。
Docker容器网络就很好的利用了Linux虚拟网络技术，在本地主机和容器内分别创建一个虚拟接口，并让他们彼此联通（这样一对接口叫veth pair）；Docker中的网络接口默认都是虚拟的接口。虚拟接口的优势就是转发效率极高（因为Linux是在内核中进行数据的复制来实现虚拟接口之间的数据转发，无需通过外部的网络设备交换），对于本地系统和容器系统来说，虚拟接口跟一个正常的以太网卡相比并没有区别，只是他的速度快很多。
Docker–Link（容器名）
？？思考一个场景，我们编写一个微服务，数据库连接地址原来是使用ip的，如果ip变化就不行了，那我们能不能使用服务名访问呢？jdbc:mysql://mysql:3306，这样的话哪怕mysql重启，我们也不需要修改配置了！docker提供了 --link的操作！
docker run --name mysql --restart=always -d -e MYSQL_ROOT_PASSWORD=123456 mysql:5.6
docker run -d --name 接收容器名(#一般是tomcat) --link 源容器(被连接容器)(#一般是mysql) --restart=always 源容器镜像名
docker run -d -p 8080:8080 --name tomcat --link mysql --restart=always -v /data/tomcat/webapps:/usr/local/tomcat/webapps tomcat
备注：–link早都过时了，我们不推荐使用！我们可以使用自定义网络的方式
自定义网络
# 命令
[root@kuangshen ~]# docker network inspect 4eb2182ac4b2 [
{
"Name": "bridge",
"Id":
"4eb2182ac4b23487e1eb6e06df56c71ab6f0adc7ccc0962b4747d0eed5ad6690",
"Created": "2020-05-11T15:44:20.131441544+08:00",
"Scope": "local",
"Driver": "bridge",
"EnableIPv6": false,
"IPAM": {
"Driver": "default",
"Options": null,
"Config": [
{
// 默认docker0是管理这个子网范围内的。0~16，也就是 255*255，去掉0个255，我们有65534可以分配的ip
// docker0网络默认可以支持创建6万多个容器ip不重复
] },
"Subnet": "172.18.0.0/16",
"Gateway": "172.18.0.1"
}
"Internal": false,
"Attachable": false,
"Ingress": false,
"ConfigFrom": {
"Network": ""
},
"ConfigOnly": false,
"Containers": {
"a3a4a17a2b707766ad4f2bb967ce1d94f658cd4cccef3bb8707395cdc71fa1e7": {
"Name": "tomcat03",
"EndpointID":
"5fe62d0be3a1343aa74f6bb77885d3657b191210cafad200e5054e1bdfe56be9",
"MacAddress": "02:42:ac:12:00:04",
"IPv4Address": "172.18.0.4/16",
"IPv6Address": ""
},
"b80da266a3ad85fcc874c5f0d3c897246ebc40533cb745bb24180237cc3167b1": {
"Name": "tomcat02",
"EndpointID":
"6232cac0c4e7fed30c9fa5eebc9238f9fc44f548f257344b5440d6d486825256",
"MacAddress": "02:42:ac:12:00:03",
"IPv4Address": "172.18.0.3/16",
"IPv6Address": ""
},
"f38239e2b405bccf8c93bd1052f336f661033b9b27ef9b3f99a018c108e06f87": {
"Name": "tomcat01",
"EndpointID":
"31dc174b8f3f15f217acdc3ac7e8a235a03d59438f863706c0143b4426772c5e",
"MacAddress": "02:42:ac:12:00:02",
"IPv4Address": "172.18.0.2/16",
"IPv6Address": ""
} },
"Options": {
"com.docker.network.bridge.default_bridge": "true",
"com.docker.network.bridge.enable_icc": "true",
"com.docker.network.bridge.enable_ip_masquerade": "true",
"com.docker.network.bridge.host_binding_ipv4": "0.0.0.0",
"com.docker.network.bridge.name": "docker0",
"com.docker.network.driver.mtu": "1500"
},
"Labels": {}
}
]
# 默认我们不配置网络，也就相当于默认值 --net bridge 使用的docker0
docker run -d -P --name tomcat01 --net bridge tomcat
# docker0网络的特点
1.它是默认的
2.域名访问不通
3.--link 域名通了，但是删了又不行
备注：聊了这么多，我们现在应该可以深刻理解docker的网络了！
实战：部署Redis集群
# 创建网卡
docker network create redis --subnet 172.38.0.0/16
# 通过脚本创建六个redis配置
for port in $(seq 1 6); \
do \
mkdir -p /mydata/redis/node-${port}/conf
touch /mydata/redis/node-${port}/conf/redis.conf
cat << EOF >/mydata/redis/node-${port}/conf/redis.conf port 6379
bind 0.0.0.0
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 172.38.0.1${port}
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
done
docker run -p 637${port}:6379 -p 1637${port}:16379 --name redis-${port} \
-v /mydata/redis/node-${port}/data:/data \
-v /mydata/redis/node-${port}/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.1${port} redis:5.0.9-alpine3.11 redis-server
/etc/redis/redis.conf; \
# 启动6个容器
docker run -p 6371:6379 -p 16371:16379 --name redis-1 \
-v /mydata/redis/node-1/data:/data \
-v /mydata/redis/node-1/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.11 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
docker run -p 6376:6379 -p 16376:16379 --name redis-6 \
-v /mydata/redis/node-6/data:/data \
-v /mydata/redis/node-6/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.16 redis:5.0.9-alpine3.11 redis-server
/etc/redis/redis.conf
# 进入一个redis，注意这里是 sh命令 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-replicas 1
# 连接集群 redis-cli -c
# 查看集群信息 cluster info
# 查看节点 cluster nodes
# set a b
# 停止到存值的容器
# 然后再次get a，发现依旧可以获取值 # 查看节点，发现高可用完全没问题
文章参考
[1]Docker官网.https://www.docker.com/[EB/OL].
[2]菜鸟Docker.https://www.runoob.com/docker/docker-tutorial.html[EB/OL].
[3]遇见狂神说.Docker最新超详细版教程通俗易懂[EB/OL].2020-05-16/至今.