Docker
目录
文章目录
前言
一.Docker的简介
1.Docker的基本概述
1.1为什么要学习Docker
1.2Docker的概念
2.容器与虚拟机比较
2.1传统的虚拟机
2.2容器化虚拟技术
2.3比较
3.Docker的优势
3.1一次构建 处处运行
4.Dcoker与podman的比较
4.1 podman是什么
4.2 Podman和Docker的主要区别
二.Docker下载与安装
1.Docker的基本组成
2.Docker的架构图解
3. 在Centos7上安装Docker
4.安装镜像加速器
5. 为什么Docker会比VM虚拟机快
三.Docker的常用命令
1. 帮助启动类命令
2.docker的镜像命令
3.docker的容器命令
3.1容器的基本命令
3.2启动守护式容器与进入容器
3.3备份容器
四.Docker镜像的底层原理
1.Docker镜像是分层的文件系统
2. Docker镜像的加载原理
3. Docker镜像commit操作案例
五. 本地推送
1.将本地镜像推送到阿里云
2. 将本地镜像推送到私有库
2.1搭建私服
2.2 将镜像推送到私服库
六. Docker容器数据卷
1.数据卷的基本概念
2.数据卷的基本案例
七.Docker中常见软件的常规安装
1.安装tomcat
2. 安装mysql
2.1简单版本安装
2.2 实战版本安装
3.安装redis
3.1简单安装
3.2实战版安装
4.安装mysql主从复制
4.1主从复制的原理
4.2 主从复制搭建的步骤
5. 分布式缓存
5.1哈希取余分区
5.2一致性哈希算法分区
5.3哈希槽分区
6. 3主3从redis集群搭建
6.1使用docker搭建redis集群
6.2 在集群状态下存储数据
6.3 redis集群容错切换迁移
7.redis集群扩容
8. redis集群缩容
八. DockerFile
1.什么是DockerFile
2. DockerFile构建过程解析
2.1DockerFile基础知识
2.2Docker执行Dockerfile的大致流程
2.3 DockerFile常用保留字指令
2.3.1FROM关键字
2.3.2MAINTAINER
2.3.3RUN
2.3.4 EXPOSE
2.3.5 WORKDIR
2.3.6 ENV
2.3.7 USER
2.3.8 VOLUME
2.3.9 ADD
2.3.10 COPY
2.3.11 CMD
2.3.12 ENTRYPOINT
2.4DockerFile案例
2.4.1前期准备工作
2.4.2 编写dockerfile文件
2.4.3 虚悬镜像
2.5 使用Dockerfile进行微服务部署
2.5.1编写一个微服务
2.5.2 编写Dockerfile,打包成镜像
2.5.3 运行容器，访问并测试
九.Docker网络
1.Docker网络的基本概述
2.Docker网络的基本命令
3. 容器内部网络ip的产生规则
4.docker网络模式的详细介绍
4.1bridge模式
4.2 host模式
4.3 none模式
4.4container模式
5.自定义网络模式
十.Docker-compose容器编排
1.Docker Compose的基本概述
2. Docker Compose的基本使用
2.1Docker Compose的基本概念
2.2Docker Compose使用的三个步骤
2.3 Docker Compose的常用基本命令
3. 使用Docker Compose进行服务编排
3.1准备微服务
3.2 编写docker-compose.yml文件
3.3 编写Dockerfile
3.4 构建镜像
3.5 启动所有docker-compose服务
十一.Docker轻量级可视化工具
1.安装可视化工具Portainer
十二.Docker容器监控之CAdvisor+InfluxDB+Granfana
1. CAdvisor InfluxDB Granfana是什么
2. 使用Docker Compose搭建CIG监控平台
3. 访问服务
3.1访问CAdvisor收集服务
3.2 访问InfluxDB存储服务
3.3 访问Granfana展现服务
十三.Swarm mode
1.Swarm的基本概念
1.1节点
1.2 服务和任务
2. 创建Swarm集群
2.1创建管理节点
2.2 增加工作节点
2.3 查看集群
3. 部署服务
3.1新建服务
3.2 查看服务
3.3 服务伸缩
3.4 删除服务
4. 使用compose文件
4.1编写docker-compose.yml
4.2部署服务
总结
文章目录
- 前言
- 一.Docker简介
- 二.Docker下载与安装
- 三.Docker的常用命令
- 四.Docker镜像的底层原理
- 五.本地推送
- 六.Docker容器数据卷
- 七.Docker中常见软件的安装
- 八.DockerFile
- 九.Docker网络
- 十.Docker-compose容器编排
- 十一.Docker轻量级可视化工具
- 十二.Docker容器监控之CAdvisor+InfluxDB+Granfana
- 十三. Swarm mode
- 总结
前言
我们写的代码会接触到好几个环境：开发环境、测试环境以及生产环境。在实施的过程中，经常会出现一些问题。比如我们开发环境使用的是 jdk1.8 的版本，而测试环境还是用 的 jdk1.7 的版本。如果我们在开发环境上编写的代码，放在测试环境上面运行，由于开发环境的差异，代码测试可能会出现意想不到的错误，这就是我们所说的代码的”水土不服”。我们需要如何确保应用能够在这些环境中运行和通过质量检测？并且在部署过程中不出现令人头疼的版本、配置问题，也无需重新编写代码和进行故障修复？
答案就是使用容器。Docker之所以发展如此迅速，也是因为它对此给出了一个标准化的解决方案-----系统平滑移植，容器虚拟化技术。
一.Docker的简介
1.Docker的基本概述
1.1为什么要学习Docker
环境配置相当麻烦，换一台机器，就要重来一次，费力费时。很多人想到，能不能从根本上解决问题，软件可以带环境安装？也就是说，安装的时候，把原始环境一模一样地复制过来。开发人员利用 Docker 可以消除协作编码时“在我的机器上可正常工作”的问题。
之前在服务器配置一个应用的运行环境，要安装各种软件，就拿现在大型的电商项目环境来说，Java/RabbitMQ/MySQL/JDBC驱动包等。安装和配置这些东西有多麻烦就不说了，它还不能跨平台。假如我们是在 Windows 上安装的这些环境，到了Linux 又得重新装。况且就算不跨操作系统，换另一台同样操作系统的服务器，要移植应用也是非常麻烦的。传统上认为，软件编码开发/测试结束后，所产出的成果即是程序或是能够编译执行的二进制字节码等。而为了让这些程序可以顺利执行，开发团队也得准备完整的部署文件，让维运团队得以部署应用程式，开发需要清楚的告诉运维部署团队，用的全部配置文件+所有软件环境。不过，即便如此，仍然常常发生部署失败的状况。Docker的出现使得Docker得以打破过去「程序即应用」的观念。透过镜像将作业系统核心除外，运作应用程式所需要的系统环境，由下而上打包，达到应用程式跨平台间的无缝接轨运作。
1.2Docker的概念
Docker是基于Go语言实现的云开源项目。Docker的主要目标是“Build，Ship and Run Any App,Anywhere”，也就是通过对应用组件的封装、分发、部署、运行等生命周期的管理，使用户的APP（可以是一个WEB应用或数据库应用等等）及其运行环境能够做到“一次镜像，处处运行”。
Linux容器技术的出现就解决了这样一个问题，而 Docker 就是在它的基础上发展过来的。将应用打成镜像，通过镜像成为运行在Docker容器上面的实例，而 Docker容器在任何操作系统上都是一致的，这就实现了跨平台、跨服务器。只需要一次配置好环境，换到别的机子上就可以一键部署好，大大简化了操作。
解决了运行环境和配置问题的软件容器，方便做持续集成并有助于整体发布的容器虚拟化技术。
2.容器与虚拟机比较
2.1传统的虚拟机
虚拟机就是带环境安装的一种解决方案。
它可以在一种操作系统里面运行另一种操作系统，比如在Windows10系统里面运行Linux系统CentOS7。应用程序对此毫无感知，因为虚拟机看上去跟真实系统一模一样，而对于底层系统来说，虚拟机就是一个普通文件，不需要了就删掉，对其他部分毫无影响。这类虚拟机完美的运行了另一套系统，能够使应用程序，操作系统和硬件三者之间的逻辑不变
传统的虚拟机技术基于安装在主操作系统上的虚拟机管理系统，在虚拟机上再安装操作系统，最后在操作系统里面安装部署各种应用。
传统的虚拟机也有一些缺点：资源占用多、冗余步骤多、启动慢
2.2容器化虚拟技术
由于前面虚拟机存在某些缺点，Linux发展出了另一种虚拟化技术：Linux容器
Linux容器是与系统其他部分隔离开的一系列进程，从另一个镜像运行，并由该镜像提供支持进程所需的全部文件。容器提供的镜像包含了应用的所有依赖项，因而在从开发到测试再到生产的整个过程中，它都具有可移植性和一致性。
Linux 容器不是模拟一个完整的操作系统而是对进程进行隔离。有了容器，就可以将软件运行所需的所有资源打包到一个隔离的容器中。容器与虚拟机不同，不需要捆绑一整套操作系统，只需要软件工作所需的库资源和设置 。系统因此而变得高效轻量并保证部署在任何环境中的软件都能始终如一地运行。
Docker容器是在操作系统层面上实现虚拟化，直接复用本地主机的操作系统。而传统虚拟机直接在硬件层面实现虚拟化。与传统的虚拟机相比，Docker体现的优势是启动速度快，占用体积小。
2.3比较
比较Docker 和传统虚拟化方式的不同之处：
1.传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上再运行所需应用进程；
2.容器内的应用进程直接运行于宿主的内核，容器内没有自己的内核且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便。
3.每个容器之间互相隔离，每个容器有自己的文件系统 ，容器之间进程不会相互影响，能区分计算资源。
3.Docker的优势
3.1一次构建 处处运行
1.更快速的应用交付和部署
传统的应用开发完成后，需要提供一堆安装程序和配置说明文档，安装部署后需根据配置文档进行繁杂的配置才能正常运行。Docker化之后只需要交付少量容器镜像文件，在正式生产环境加载镜像并运行即可，应用安装配置在镜像里已经内置好，大大节省部署配置和测试验证时间。
2.更便捷的升级和扩缩容
随着微服务架构和Docker的发展，大量的应用会通过微服务方式架构，应用的开发构建将变成搭乐高积木一样，每个Docker容器将变成一块“积木”，应用的升级将变得非常容易。当现有的容器不足以支撑业务处理时，可通过镜像运行新的容器进行快速扩容，使应用系统的扩容从原先的天级变成分钟级甚至秒级。
3.更简单的系统运维
应用容器化运行后，生产环境运行的应用可与开发、测试环境的应用高度一致，容器会将应用程序相关的环境和状态完全封装起来，不会因为底层基础架构和操作系统的不一致性给应用带来影响，产生新的BUG。当出现程序异常时，也可以通过测试环境的相同容器进行快速定位和修复。
4.更高效的计算资源利用
Docker是内核级虚拟化，其不像传统的虚拟化技术一样需要额外的Hypervisor支持，所以在一台物理机上可以运行很多个容器实例，可大大提升物理服务器的CPU和内存的利用率。
Docker借鉴了标准的集装箱概念。集装箱将装好的货物运送到世界各地。Docker将这个模型运用到自己的设计中，唯一不同的是集装箱运送的是货物，Docker运输的是软件。
4.Dcoker与podman的比较
4.1 podman是什么
Podman是RedHat的一款产品。Podman是一个无守护进程的容器引擎，用于在Linux系统上开发、管理和运行OCI容器。容器既可以以root身份运行，也可以在无root模式下运行。Podman是一款集合了命令集的工具，设计初衷是为了处理容器化进程的不同任务，可以作为一个模块化框架工作。它的工具集包括：
Podman：Pod和容器镜像管理器
Buildah：容器镜像生成器
Skopeo：容器镜像检查管理器
Runc：容器运行器和特性构建器，并传递给Podman和Buildah
Crun：可选运行时，为Rootless容器提供更大的灵活性、控制和安全性4.2 Podman和Docker的主要区别
1、守护进程
Docker使用守护进程，一个正在后台运行的程序，来创建镜像和运行容器。Podman是无守护进程的架构，这意味着它可以在启动容器的用户下运行容器。
2、安全性
Podman允许容器使用Rootless特权。Rootless容器被认为比Root特权的容器更安全。在Docker中，守护进程拥有Root权限，这使得它们易成为攻击者的首选入侵点。
Podman中的容器默认情况下不具有Root访问权限，这在Root级别和Rootless级别之间添加了一个自然屏障，提高了安全性。不过，Podman可以同时运行Root容器和Rootless容器。
3、镜像构建
作为一款自给自足的工具，Docker可以自己构建容器镜像。Podman则需要另一种名为Buildah的工具的辅助。
4、多合一和模块化
Docker是一个独立的、强大的工具，在整个循环中处理所有的容器化任务，有优点也有缺点。Podman采用模块化的方法，依靠专门的工具来完成特定的任务
二.Docker下载与安装
Docker官网：http://www.docker.com
Docker Hub官网: https://hub.docker.com/
Docker并非是一个通用的容器工具，它依赖于已存在并运行的linux内核环境。Docker实质上是在已经运行的Linux下制造了一个隔离的文件环境，因此它执行的效率几乎等同于所部署的linux主机。因此Docker必须部署在Linux内核的系统上。如果其它系统想部Docker，必须安装一个虚拟的Linux环境
1.Docker的基本组成
镜像：
Docker镜像就是一个只读的模板。镜像可以用来创建 Docker 容器，一个镜像可以创建很多容器。它也相当于是一个root文件系统。比如官方镜像centos:7 就包含了完整的一套 centos:7 最小系统的 root 文件系统。相当于容器的“源代码”，docker镜像文件类似于Java的类模板，而docker容器实例类似于java和c++中new出来的实例对象。容器与镜像的关系就类似于Java面向编程中的类与对象的关系。
容器：
1 从面向对象角度
Docker 利用容器独立运行的一个或一组应用，应用程序或服务运行在容器里面，容器就类似于一个虚拟化的运行环境，容器是用镜像创建的运行实例。就像是Java中的类和实例对象一样，镜像是静态的定义，容器是镜像运行时的实体。容器为镜像提供了一个标准的和隔离的运行环境，它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台。
2 从镜像容器角度
可以把容器看做是一个简易版的 Linux 环境（包括root用户权限、进程空间、用户空间和网络空间等）和运行在其中的应用程序。
仓库：
仓库是集中存放镜像文件的场所。类似于Maven仓库，存放各种jar包的地方；github仓库，存放各种git项目的地方；
Docker公司提供的官方registry被称为Docker Hub，存放各种镜像模板的地方。仓库分为公开仓库（Public）和私有仓库（Private）两种形式。最大的公开仓库是Docker Hub(https://hub.docker.com/)，存放了数量庞大的镜像供用户下载。国内的公开仓库包括阿里云 、网易云等。
小结：
需要正确的理解仓库/镜像/容器这几个概念:
Docker 本身是一个容器运行载体或称之为管理引擎。我们把应用程序和配置依赖打包好形成一个可交付的运行环境，这个打包好的运行环境就是image镜像文件。只有通过这个镜像文件才能生成Docker容器实例(类似Java中new出来一个对象)。image文件可以看作是容器的模板。Docker 根据 image 文件生成容器的实例。同一个 image 文件，可以生成多个同时运行的容器实例。
镜像文件
image 文件生成的容器实例，本身也是一个文件，称为镜像文件。
容器实例
一个容器运行一种服务，当我们需要的时候，就可以通过docker客户端创建一个对应的运行实例，也就是我们的容器。
仓库
就是放一堆镜像的地方，我们可以把镜像发布到仓库中，需要的时候再从仓库中拉下来就可以了。
2.Docker的架构图解
Docker是一个Client-Server结构的系统，Docker守护进程运行在主机上， 然后通过Socket连接从客户端访问，守护进程从客户端接受命令并管理运行在主机上的容器。 容器，是一个运行时环境，就是我们前面说到的集装箱。基于这幅架构图，我们可以进一步分析Docker底层的运行流程：
3. 在Centos7上安装Docker
安装gcc环境
[root@shjava2202 ~]# yum -y install gcc
[root@shjava2202 ~]# yum -y install gcc-c++安装需要的软件包
[root@shjava2202 ~]# yum install -y yum-utils设置镜像仓库
[root@shjava2202 ~]# yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo更新yum软件包索引
[root@shjava2202 ~]# yum makecache fast安装Docker
[root@shjava2202 ~]# yum -y install docker-ce docker-ce-cli containerd.io启动Docker
[root@shjava2202 ~]# systemctl start docker查看Docker安装的版本信息
[root@shjava2202 ~]# docker version
Client: Docker Engine - Community
Version: 20.10.21
API version: 1.41
Go version: go1.18.7
Git commit: baeda1f
Built: Tue Oct 25 18:04:24 2022
OS/Arch: linux/amd64
Context: default
Experimental: true
Server: Docker Engine - Community
Engine:
Version: 20.10.21
API version: 1.41 (minimum version 1.12)
Go version: go1.18.7
Git commit: 3056208
Built: Tue Oct 25 18:02:38 2022
OS/Arch: linux/amd64
Experimental: false
containerd:
Version: 1.6.12
GitCommit: a05d175400b1145e5e6a735a6710579d181e7fb0
runc:
Version: 1.1.4
GitCommit: v1.1.4-0-g5fd4c4d
docker-init:
Version: 0.19.0
GitCommit: de40ad0测试是否安装成功
[root@shjava2202 ~]# docker run hello-world
卸载Docker
[root@shjava2202 ~]# systemctl stop docker
[root@shjava2202 ~]# yum remove docker-ce docker-ce-cli containerd.io
[root@shjava2202 ~]# rm -rf /var/lib/docker
[root@shjava2202 ~]# rm -rf /var/lib/containerd4.安装镜像加速器
首先我们需要注册一个属于自己的阿里云账户(可复用淘宝账号)。并登陆
获取加速器地址连接
第一步：登陆阿里云开发者平台
第二步：点击控制台
第三步：选择容器镜像服务
第四步：获取加速器地址
第五步：粘贴脚本执行
[root@shjava2202 ~]# mkdir -p /etc/docker在执行如下shell脚本：
tee /etc/docker/daemon.json <<-'EOF'
{
"registry-mirrors": ["https://2j0viskq.mirror.aliyuncs.com"]
}
EOF
[root@shjava2202 ~]# systemctl daemon-reload
[root@shjava2202 ~]# systemctl restart docker第六步：验证是否配置成功
如果出现了以上信息，说明镜像加速器配置没有问题。
那大家思考一个问题，当我们运行docker run命令的时候，这个命令做了什么?
输出这段提示以后，hello world就会停止运行，容器自动终止。
我们可以通过一幅图来描述docker run 命令的运行过程。
5. 为什么Docker会比VM虚拟机快
(1) docker有着比虚拟机更少的抽象层
由于docker不需要Hypervisor(虚拟机)实现硬件资源虚拟化,运行在docker容器上的程序直接使用的都是实际物理机的硬件资源。因此在CPU、内存利用率上docker将会在效率上有明显优势。
(2) docker利用的是宿主机的内核,而不需要加载操作系统OS内核
当新建一个容器(docker run)时,docker不需要和虚拟机一样重新加载一个操作系统内核。进而避免引寻、加载操作系统内核返回等比较费时费资源的过程,当新建一个虚拟机时,虚拟机软件需要加载OS,返回新建过程是分钟级别的。而docker由于直接利用宿主机的操作系统,则省略了返回过程,因此新建一个docker容器只需要几秒钟。
三.Docker的常用命令
1. 帮助启动类命令
启动docker
[root@shjava101 ~]# systemctl start docker #启动docker
[root@shjava101 ~]# systemctl status docker #查看docker的运行状态
[root@shjava101 ~]# systemctl restart docker #重启docker服务
[root@shjava101 ~]# systemctl stop docker #停止docker服务
[root@shjava101 ~]# docker --help #查看docker帮助文档 
如果我们想查看指定某条docker命令的帮助信息呢？
语法格式是: docker 具体命令 --help。 比如我们现在想查看docker的cp命令详细信息
[root@shjava101 ~]# docker cp --help 
2.docker的镜像命令
docker images 列出本地主机上的镜像
[root@shjava101 ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
hello-world latest feb5d9fea6a5 15 months ago 13.3kB 
REPOSITORY：表示镜像的仓库源
TAG：镜像的标签版本号。在下载镜像的时候，如果默认不加版本号，就会下载默认最新版本的镜像。如果加上指定版本号的镜像，下载的就是对应版本的镜像。
IMAGE ID：镜像ID
CREATED：镜像创建时间
SIZE：镜像大小
同一仓库源可以有多个 TAG版本，代表这个仓库源的不同个版本，我们使用REPOSITORY:TAG 来定义不同的镜像。
如果我们想深入学习docker images的命令，我们可以使用help指令查看关于dockerimages的帮助文档。
[root@shjava101 ~]# docker images --help
Usage: docker images [OPTIONS] [REPOSITORY[:TAG]]
List images
Options:
-a, --all Show all images (default hides
intermediate images)
--digests Show digests
-f, --filter filter Filter output based on conditions
provided
--format string Pretty-print images using a Go template
--no-trunc Don't truncate output
-q, --quiet Only show image IDs
[root@shjava101 ~]# docker images -a
REPOSITORY TAG IMAGE ID CREATED SIZE
hello-world latest feb5d9fea6a5 15 months ago 13.3kB
[root@shjava101 ~]# docker images -q
feb5d9fea6a5-a :列出本地所有的镜像（含历史映像层）
-q :只显示镜像ID。
docker search 某个XXX镜像名字 指定搜索某个镜像的名称。
[root@shjava101 ~]# docker search redis 
搜索镜像出现的选项是什么意思呢:
我们也可以携带一些参数，比如-limit。--limit : 只列出N个镜像，默认25个
[root@shjava101 ~]# docker search --limit 5 redisdocker pull 某个XXX镜像名字 拉取指定的镜像到本地(下载镜像)
语法：docker pull 镜像名字[:TAG]
[root@shjava101 ~]# docker pull mysql # 没有带标签，就下载的是最新版本的mysql镜像
[root@shjava101 ~]# docker pull redis:6.0.8 #下载指定标签的redis镜像 
比如给大家演示下载ubuntu镜像：
[root@shjava101 ~]# docker pull ubuntu #默认下载最新版本的镜像
Using default tag: latest
latest: Pulling from library/ubuntu
7b1a6ab2e44d: Pull complete
Digest:
sha256:626ffe58f6e7566e00254b638eb7e0f3b11d4da9675088f4781a50ae28
8f3322
Status: Downloaded newer image for ubuntu:latest
docker.io/library/ubuntu:latest
[root@shjava101 ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
ubuntu latest ba6acccedd29 14 months ago 72.8MB
hello-world latest feb5d9fea6a5 15 months ago 13.3kB
redis 6.0.8 16ecd2772934 2 years ago 104MB
在linux里面我们如何插件硬盘的使用情况，是不是可以使用df -h命令。在docker里面我们也想查看镜像/容器的占用空间，我们应该如何使用呢：
语法格式: docker system df 查看镜像/容器/数据卷所占的空间
docker rmi 某个XXX镜像名字ID 删除某个镜像，注意：不能删除正在运行容器的镜像！
[root@shjava101 ~]# docker rmi hello-world # 可以根据镜像名称删除
Error response from daemon: conflict: unable to remove repository reference "hello-world" (must force) - container eec46ce5392d is using its referenced image feb5d9fea6a5
[root@shjava101 ~]# docker rmi feb5d9fea6a5 # 也可以根据镜像id删除，因为镜像id是唯一的。
Error response from daemon: conflict: unable to delete feb5d9fea6a5 (must be forced) - image is being used by stopped container eec46ce5392d但是此时删除报错，因为删除的时候，当前镜像存在正在运行的容器。我们可以使用-f参数来指定强制删除，但是强制删除的话，正在运行的容器也就不复杂在了
[root@shjava101 ~]# docker rmi -f feb5d9fea6a5
docker rmi -f 镜像名1:TAG 镜像名2:TAG 删除多镜像可以使用这个命令
[root@shjava101 ~]# docker rmi -f ubuntu:latest redis:6.0.8也可以直接删除全部镜像(慎用！！！)
[root@shjava101 ~]# docker rmi -f $(docker images -qa)3.docker的容器命令
3.1容器的基本命令
1.启动容器：
启动容器命令的语法格式是： docker run [OPTIONS] IMAGE [COMMAND] [ARG...]
OPTIONS参数说明(有些是一个减号，有些是两个减号):
--name="容器新名字" 为容器指定一个名称；
-d: 后台运行容器并返回容器ID，也即启动守护式容器(后台运行)；
-i：以交互模式运行容器，通常与 -t 同时使用；
-t：为容器重新分配一个伪输入终端，通常与 -i 同时使用；也即启动交互式容器(前台有伪终端，等待交互)；
-P: 随机端口映射，大写P
-p: 指定端口映射，小写p
现在我们如何启动一个Ubuntu容器呢？使用docker run ubuntu吗？我们可以试一下：
[root@shjava101 ~]# docker run ubuntu我们发现启动之后，没有任何反应，因为我们希望启动的是一个交互式的容器，也就是用户可以在终端输入命令的容器。那如何启动一个交互式的容器呢？
根据上面的语法规则我们可以这样启动：
[root@shjava101 ~]# docker run -it ubuntu /bin/bash
root@f6d5e6eb2c5c:/# 参数说明：
-i: 交互式操作。
-t: 终端。
ubuntu: ubuntu镜像。
/bin/bash：放在镜像名后的是命令，这里我们希望有个交互式 Shell，用来解释执行linux指令。因此用的是 /bin/bash。
要退出终端，直接输入 exit。
docker ps 列出正在运行的容器
我们另起一个终端，运行docker ps命令。
[root@shjava101 /]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS
PORTS NAMES
f05e76e5e32c ubuntu "/bin/bash" 11 seconds ago Up 10
seconds optimistic_swirlesNAMES:指的启动的容器名字，如果你不指定，系统就会给你随机指的一个名字。如何在启动容器的时候也指定容器的名字呢？
我们可以使用--name参数指定。
[root@shjava101 /]# docker run -it --name=u1 ubuntu /bin/bash我们再次查看正在运行的容器。
[root@shjava101 ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS
PORTS NAMES
6d2d86512480 ubuntu "/bin/bash" 11 seconds ago Up 10
seconds u1我们发现正在运行的容器的名字就是我们自己定义的了。
这个命令还可以携带一些常用的参数：
-a :列出当前所有正在运行的容器+历史上运行过的
-l :显示最近创建的容器。
-n：显示最近n个创建的容器。
-q :只显示正在运行的容器编号。
下面我们来具体演示：
[root@shjava101 ~]# docker ps -a # 列出所有容器(正在运行的以及历史运行的)
CONTAINER ID IMAGE COMMAND CREATED
STATUS PORTS NAMES
6d2d86512480 ubuntu "/bin/bash" 5 minutes ago Up 5
minutes u1
2377079e316a ubuntu "/bin/bash" 5 minutes ago
Exited (0) 5 minutes ago
[root@shjava101 ~]# docker ps -l #罗列最近运行的容器
CONTAINER ID IMAGE COMMAND CREATED STATUS
PORTS NAMES
6d2d86512480 ubuntu "/bin/bash" 6 minutes ago Up 6
minutes u1
[root@shjava101 ~]# docker ps -n 2 # 罗列最近运行的2个容器
CONTAINER ID IMAGE COMMAND CREATED STATUS
PORTS NAMES
6d2d86512480 ubuntu "/bin/bash" 6 minutes ago Up 6
minutes u1
2377079e316a ubuntu "/bin/bash" 7 minutes ago Exited (0)
7 minutes ago hopeful_davinci
[root@shjava101 ~]# docker ps -q # 只显示最近运行的容器的id
6d2d865124802.退出容器的命令
上面提到，要退出容器终端，可以使用exit命令，但是使用exit命令退出会导致容器终止执行！如果退出容器终端，不影响容器正在运行可以吗，答案是可以的。这个也是退出容器的两种机制
exit run进去容器，exit退出，容器停止
ctrl+p+q run进去容器，ctrl+p+q退出，容器不停止
3.启动已停止运行的容器
语法格式：docker start 容器ID或者容器名
[root@shjava101 /]# docker start 2377079e316a
2377079e316a
[root@shjava101 /]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS
PORTS NAMES
6d2d86512480 ubuntu "/bin/bash" 22 minutes ago Up 22
minutes u1
2377079e316a ubuntu "/bin/bash" 22 minutes ago Up 17
seconds hopeful_davinci我们发现之前已经停止的容器也运行起来了。
4.重启容器
语法格式：docker restart 容器ID或者容器名
[root@shjava101 /]# docker restart 2377079e316a 5.停止容器
语法格式：docker stop 容器ID或者容器名
[root@shjava101 /]# docker stop 2377079e316a6. 强制停止容器
语法格式：docker kill 容器ID或容器名
[root@shjava101 /]# docker kill 2377079e316a7. 删除已停止的容器
语法格式：docker rm 容器ID
[root@shjava101 /]# docker rm 2377079e316a如果我们要删除正在运行的容器呢？
此时需要加上一个-f参数
[root@shjava101 /]# docker rm -f 2377079e316a我们也可以一次性删除多个容器实例，但是一般不建议大家这么使用：
[root@shjava101 /]# docker rm -f $(docker ps -a -q)
或者
[root@shjava101 /]# docker ps -a -q | xargs docker rm # xargs 是linux里的一个显式参数3.2启动守护式容器与进入容器
在大部分的场景下，我们希望 docker 的服务是在后台运行的，我们可以过 -d 指定容器的后台运行模式。为了显示区别，我们先用前台交互的方式启动容器:
[root@shjava101 /]# docker run -it redis:6.0.8此时会以前台运行redis的方式显示
但是这种启动方式会霸占我们整个linux终端，导致我们不能做其他的事情。所以我们应该以后台的形式启动守护式容器。如何启动？
我们可以使用docker run -d 容器名 这个命令。
[root@shjava101 /]# docker run -d redis:6.0.8
38b51ae774dd345fef245de93d2285987831c9119da93421c6a4304e89447ec5我们查看容器是否启动？
[root@shjava101 /]# docker ps
CONTAINER ID IMAGE COMMAND CREATED
STATUS PORTS NAMES
38b51ae774dd redis:6.0.8 "docker-entrypoint.s…" 4 seconds
ago Up 3 seconds 6379/tcp boring_poitras
6d2d86512480 ubuntu "/bin/bash" About an
hour ago Up About an hour u1我们如何进入到redis容器的内部，我们马上说到。现在我们再看几个和容器相关的其他命令。
查看容器日志的命令 docker logs 容器id
[root@shjava101 /]# docker logs 38b51ae774dd
我们发现容器启动的日志信息全部被封装起来了。
查看容器内运行的进程 docker top 容器ID
在linux里面，我们可以使用top命令动态查看进程信息，在docker里面我们可以使用docker top 命令查看指定容器的进程信息。
[root@shjava101 /]# docker top 38b51ae774dd
查看容器内部具体细节命令 docker inspect 容器ID
[root@shjava101 /]# docker inspect 38b51ae774dd 
接下来我们讨论如何进入正在运行的容器并以命令行交互。我们先以前面运行的ubuntu容器为例：
我们可以通过docker exec 命令进入容器内部
[root@shjava101 /]# docker exec -it 6d2d86512480 /bin/bash
root@6d2d86512480:/# ls
bin boot dev etc home lib lib32 lib64 libx32 media mnt
opt proc root run sbin srv sys tmp usr var此时我们使用exit命令退出容器。
root@6d2d86512480:/# exit
exit
[root@shjava101 /]# docker ps
CONTAINER ID IMAGE COMMAND CREATED
STATUS PORTS NAMES
38b51ae774dd redis:6.0.8 "docker-entrypoint.s…" 17 minutes
ago Up 17 minutes 6379/tcp boring_poitras
6d2d86512480 ubuntu我们发现，当我们退出容器之后，容器依然在运行。
我们还可以使用 docker attach 容器id 的命令进入容器，但是用exit命令退出会导致容器停止
[root@shjava101 /]# docker attach 6d2d86512480
root@6d2d86512480:/# exit
exit
[root@shjava101 /]# docker ps
CONTAINER ID IMAGE COMMAND CREATED
STATUS PORTS NAMES
38b51ae774dd redis:6.0.8 "docker-entrypoint.s…" 22 minutes
ago Up 22 minutes 6379/tcp boring_poitras我们发现ubuntu运行的容器已经停止了。
所以推荐大家使用 docker exec 命令，因为退出容器终端，不会导致容器的停止。
我们现在如何进入到redis容器的内部呢
[root@shjava101 /]# docker exec -it 38b51ae774dd /bin/bash
root@38b51ae774dd:/data# redis-cli
127.0.0.1:6379> set username eric
OK
127.0.0.1:6379> get username
"eric"
127.0.0.1:6379>3.3备份容器
(1) 从容器内拷贝文件到主机上
语法格式：docker cp 容器ID:容器内路径 目的主机路径
需求：我们先启动ubuntu容器，然后在容器的tmp目录创建一个文件。然后把这个文件拷贝至宿主机中。
[root@shjava101 /]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
ubuntu latest ba6acccedd29 14 months ago 72.8MB
redis 6.0.8 16ecd2772934 2 years ago 104MB
[root@shjava101 /]# docker run -it ubuntu /bin/bash
root@608d2057e7e5:/# cd /tmp
root@608d2057e7e5:/tmp# touch a.txt
root@608d2057e7e5:/tmp# ls
a.txt我们使用命令尝试拷贝：
[root@shjava101 /]# docker ps
CONTAINER ID IMAGE COMMAND CREATED
STATUS PORTS NAMES
608d2057e7e5 ubuntu "/bin/bash" 13 minutes
ago Up 13 minutes reverent_stonebraker
38b51ae774dd redis:6.0.8 "docker-entrypoint.s…" About an
hour ago Up About an hour 6379/tcp boring_poitras
[root@shjava101 /]# docker cp 608d2057e7e5:/tmp/a.txt /tmp/a.txt
[root@shjava101 /]# cd /tmp
[root@shjava101 tmp]# ll
total 1504
-rw-r--r--. 1 root root 0 Dec 22 21:17 a.txt我们发现，可以成功将容器内部的文件拷贝出来。
(2) 导入和导出容器
上面是将文件中的某个内容导出来，我们也可以将整个容器导出来，以tar.gz的文件保存。我们可以使用export命令实现。
语法格式：docker export 容器ID > 文件名.tar
[root@shjava101 tmp]# docker export 608d2057e7e5 > ubuntu.tar.gz
[root@shjava101 tmp]# ll
-rw-r--r--. 1 root root 75158016 Dec 22 21:47 ubuntu.tar.gz我们发现容器成功备份。
接下来我们分别删除运行的ubuntu镜像和运行的ubuntu容器。
现在我们通过ubuntu.tar.gz来导入一个新镜像：
语法格式是：cat 文件名.tar | docker import - 镜像用户/镜像名:镜像版本号
[root@shjava101 tmp]# cat ubuntu.tar.gz | docker import - wen/ubuntu:1.0
sha256:575629a1394b19d888621928a842b706a385fe1d3d862d85f6be3f765d88656c
[root@shjava101 tmp]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
wen/ubuntu 1.0 575629a1394b 16 seconds ago 72.8MB
redis 6.0.8 16ecd2772934 2 years ago 104MB接下来我们启动容器：
[root@shjava101 tmp]# docker run -it 575629a1394b /bin/bash # 启动容器
root@e53f29855791:/# cd /tmp
root@e53f29855791:/tmp# ll
total 0
drwxrwxrwt. 2 root root 19 Dec 22 13:17 ./
drwxr-xr-x. 1 root root 6 Dec 22 13:55 ../
-rw-r--r--. 1 root root 0 Dec 22 13:17 a.txt我们发现容器成功启动，并且之前创建的文件也存在。说明我们导入成功！
四.Docker镜像的底层原理
1.Docker镜像是分层的文件系统
首先我们需要明白docker镜像是什么?以我们的pull为例，在下载的过程中我们可以看到docker的镜像好像是在一层一层的在下载。
这种分层的镜像就好像分层的蛋糕。每个分层的镜像都有单独的功能，然后汇聚成一起对外暴露成一个整体的镜像。这种分层的镜像我们又称为联合文件系统
联合文件系统是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下。Union 文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（类似于JAVA中的Object类），可以制作各种具体的应用镜像
特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录
2. Docker镜像的加载原理
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等等。
bootfs：包含 bootloader（引导加载程序）和 kernel（内核） 。
rootfs： root 文件系统，包含的就是典型 Linux 系统中的/dev，/proc，/bin， /etc 等标准目录和文件。
那为什么Docker镜像要设计成这种分层的镜像呢?
其实就是为了复用！做到资源共享！比如我们安装 nginx 也需要 jdk镜像。如果我们之前下载过 tomcat，tomcat 下载是需要 jdk 镜像 的。由于 jdk 镜像之前已经下载过，所以下载 nginx 镜像就不要再下载 jdk 了。
需要注意的是：Docker镜像层都是只读的，容器层是可写的。当容器启动时，一个新的可写层被加载到镜像的顶部。这一层通常被称作“容器层”，“容器层”之下的都叫“镜像层”。
所以，所有对容器的改动 - 无论添加、删除、还是修改文件都只会发生在容器层中。只有容器层是可写的，容器层下面的所有镜像层都是只读的。
3. Docker镜像commit操作案例
基于上面的结论，我们可以对正在运行的容器进行修改，自定义一些功能，然后我们再打成新的镜像。这样新的镜像就有新的功能了。我们运行一个ubuntu镜像，我们发现在镜像里面无法使用vim命令，因为这个ubuntu镜像只是包括了其最基本的内核命令。
[root@shjava101 ~]# docker run -it 575629a1394b /bin/bash
root@6fad0baadb12:/# vim a.txt
bash: vim: command not found此时我们就想给这个正在运行的容器添加vim功能。那应该怎么办呢？我们现在ubuntu容器里面安装vim编辑器。
root@6fad0baadb12:/# apt-get update
root@6fad0baadb12:/# apt-get -y install vim安装完成以后，我们就可以在容器里面使用vim编辑器进行文件的编辑了
root@6fad0baadb12:/# vim a.txt
root@6fad0baadb12:/# cat a.txt
hello docker接下来我们需要将这个运行的容器重新制作成一个带有vim功能的ubuntu镜像。我们使用docker commit命令实现。docker commit命令的作用就是提交容器副本使之成为一个新的镜像。
语法格式：
docker commit -m="提交的描述信息" -a="作者" 容器ID 要创建的目标镜像名:[标签名]
我们ctrl+P+Q快捷键退出到容器外部，执行命令：
[root@shjava101 ~]# docker commit -m="add vim" -a="krisswen" 6fad0baadb12 linux1:1.0 
我们发现我们的镜像制作成功，并且相对于原来的ubuntu镜像，大了不少，为什么？因为我们加了vim功能，相当于又加了一层新的镜像，所以变大了。
接下来我们运行我们自己做的镜像：
[root@shjava101 ~]# docker run -it a31aabe9e714 /bin/bash
root@c4b8c5a059f9:/# ls
a.txt bin boot dev etc home lib lib32 lib64 libx32
media mnt opt proc root run sbin srv sys tmp usr var
root@c4b8c5a059f9:/# vim b.txt我们发现我们自己制作的镜像确实带有vim功能了。
总结：Docker中的镜像分层，支持通过扩展现有镜像，创建新的镜像。类似Java继承于一个Base基础类，自己再按需扩展。新镜像是从 base 镜像一层一层叠加生成的。每安装一个软件，就在现有镜像的基础上增加一层
五. 本地推送
1.将本地镜像推送到阿里云
我们自己制作好镜像以后，我们也可以推送到远端，这样别人也可以去使用我们的镜像。
接下来我们将本地镜像推送到阿里云。在推送之前，我们首先要进入阿里云开发者平台创建仓库镜像。
第一步：选择控制台，进入容器镜像服务
第二步：选择个人实例
第三步：进入个人实例，创建命名空间
然后将仓库设置成公开类型
第四步：创建镜像仓库
点击下一步：
我们点击创建镜像仓库就可以了。
创建完成以后，我们需要注意以下几个命令:
[root@shjava101 ~]# docker login --username=文威_krisswen registry.cn-hangzhou.aliyuncs.com #先远程登录
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/#crede
ntials-store
Login Succeeded
[root@shjava101 ~]# docker tag a31aabe9e714 registry.cn -hangzhou.aliyuncs.com/krisswen/linux1:1.0
[root@shjava101 ~]# docker push registry.cn- hangzhou.aliyuncs.com/krisswen/linux1:1.0
The push refers to repository [registry.cn-
hangzhou.aliyuncs.com/krisswen/linux1]
83a3737e56ff: Pushed
2499a75b89bf: Pushed
1.0: digest:
sha256:e197b6ad96975283cd6455512f75cc956dc940c4370c526d47958dc014
3353ff size: 741我们如何从阿里云拉取镜像呢?
[root@shjava101 ~]# docker pull registry.cn-hangzhou.aliyuncs.com/krisswen/linux1:1.0
1.0: Pulling from krisswen/linux1
3d6881d9c553: Already exists
30dfd2f8b48a: Already exists
Digest:
sha256:e197b6ad96975283cd6455512f75cc956dc940c4370c526d47958dc014
3353ff
Status: Downloaded newer image for registry.cn-
hangzhou.aliyuncs.com/krisswen/linux1:1.0
registry.cn-hangzhou.aliyuncs.com/krisswen/linux1:1.0
[root@shjava101 ~]# docker images
REPOSITORY TAG
IMAGE ID CREATED SIZE
registry.cn-hangzhou.aliyuncs.com/krisswen/linux1 1.0
a31aabe9e714 58 minutes ago 181MB
wen/ubuntu 1.0
575629a1394b 2 days ago 72.8MB
tomcat latest
fb5657adc892 12 months ago 680MB2. 将本地镜像推送到私有库
2.1搭建私服
第一步：下载镜像Docker Registry
[root@shjava101 ~]# docker pull registry 第二步：运行私服容器
运行私有库Registry，相当于本地有个私有Docker hub
[root@shjava101 ~]# docker run -d -p 5000:5000 -v /krisswen/myregistry/:/tmp/registry --privileged=true registry # 先这么运行，不用管为什么
c2759846ce33fe3f57f48ccc747158e9aa4bb354517de0da9b0f3d42f8fb05492.2 将镜像推送到私服库
演示创建一个新镜像，ubuntu安装ifconfig命令
[root@shjava101 ~]# docker pull ubuntu # 重新下载一个新的ubuntu镜像
[root@shjava101 ~]# docker images
REPOSITORY TAG
IMAGE ID CREATED SIZE
registry.cn-hangzhou.aliyuncs.com/krisswen/linux1 1.0
a31aabe9e714 2 hours ago 181MB
ubuntu latest
ba6acccedd29 14 months ago 72.8MB
[root@shjava101 ~]# docker run -it ba6acccedd29 /bin/bash # 运行ubuntu镜像原始的Ubuntu镜像是不带着ifconfig命令的。
root@8b4bcfd9196e:/# ifconfig
bash: ifconfig: command not found接下来我们来完整ifconfig命令，并确保该命令可以正常使用
root@8b4bcfd9196e:/# apt-get update
root@8b4bcfd9196e:/# apt-get install net-tools
root@8b4bcfd9196e:/# ifconfig # 我们发现可以正常测试通过
eth0: flags=4163 mtu 1500
inet 172.17.0.3 netmask 255.255.0.0 broadcast
172.17.255.255
ether 02:42:ac:11:00:03 txqueuelen 0 (Ethernet)
RX packets 8668 bytes 25347876 (25.3 MB)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 8533 bytes 467687 (467.6 KB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions
0
lo: flags=73 mtu 65536
inet 127.0.0.1 netmask 255.0.0.0
loop txqueuelen 1000 (Local Loopback)
RX packets 0 bytes 0 (0.0 B)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 0 bytes 0 (0.0 B)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions
0 我们Ctrl + P + Q退出容器。接下来我们开始进行镜像推送。
第一步：安装镜像
语法格式：docker commit -m="提交的描述信息" -a="作者" 容器ID 要创建的目标镜像名:[标签名]
[root@shjava101 ~]# docker commit -m="ifconfig" -a="krisswen" 8b4bcfd9196e ubuntu1:1.1
sha256:238f2c8c8320fe31b113148b4cc8e0b0c48ac52f12bccab806ac6c86ca
b55c2f
[root@shjava101 ~]# docker images
REPOSITORY TAG
IMAGE ID CREATED SIZE
ubuntu1 1.1
238f2c8c8320 10 seconds ago 114MB第二步：使用curl工具验证私服库上有什么镜像
[root@shjava101 ~]# curl -XGET http://192.168.10.145:5000/v2/_catalog {"repositories":[]}可以看到，目前私服库没有任何镜像上传过。
第三步：将新镜像ubuntu1:1.1修改符合私服规范的Tag
命令格式： docker tag 镜像:Tag Host:Port/Repository:Tag
[root@shjava101 ~]# docker tag ubuntu1:1.1 192.168.10.145:5000/ubuntu1:1.1我们查看修改之后的效果：
第四步：修改docker配置文件使之支持http
docker默认不允许http方式推送镜像，通过配置来取消这个限制。vim命令新增如下内容：vim /etc/docker/daemon.json
"insecure-registries": ["192.168.10.145:5000"] 
最好是重新启动docker。并且保证linux防火墙没有对5000端口拦截。
第五步：push推送到私服库
由于重新启动了docker，之前运行的docker registry容器也停止了，需要重新启动这个容器。
[root@shjava101 ~]# docker run -d -p 5000:5000 -v /krisswen/myregistry/:/tmp/registry --privileged=true registry
[root@shjava101 ~]# docker push 192.168.10.145:5000/ubuntu1:1.1# 推送镜像到私服
The push refers to repository [192.168.10.145:5000/ubuntu1]
7aa85451c54f: Pushed
9f54eef41275: Pushed
1.1: digest:
sha256:2dd023374760f44dccb406bc07e710baf0e0e6208186a48fd26aadf2d2
9136e1 size: 741第六步：验证私服库上是否存在镜像
[root@shjava101 ~]# curl -XGET http://192.168.10.145:5000/v2/_catalog {"repositories":["ubuntu1"]}第七步：从私服上拉取镜像
[root@shjava101 ~]# docker pull 192.168.10.145:5000/ubuntu1:1.1 # 从私服上拉取镜像
1.1: Pulling from ubuntu1
7b1a6ab2e44d: Already exists
d4586c2bf028: Pull complete
Digest:
sha256:2dd023374760f44dccb406bc07e710baf0e0e6208186a48fd26aadf2d2
9136e1
Status: Downloaded newer image for
192.168.10.145:5000/ubuntu1:1.1
192.168.10.145:5000/ubuntu1:1.1
[root@shjava101 ~]# docker images
REPOSITORY TAG
IMAGE ID CREATED SIZE
192.168.10.145:5000/ubuntu1 1.1
238f2c8c8320 41 minutes ago 114MB六. Docker容器数据卷
1.数据卷的基本概念
[root@shjava101 ~]# docker run -d -p 5000:5000 -v /krisswen/myregistry/:/tmp/registry --privileged=true registry c2759846ce33fe3f57f48ccc747158e9aa4bb354517de0da9b0f3d42f8fb0549这个-v参数是什么意思？就是实现数据卷的挂载。我们以上面这个命令为例：
/krisswen/myregistry/： 定义的是宿主机的目录，该目录如果不存在，会被自动创建。
/tmp/registry： 容器内部的数据目录。
--privileged=true ：必须要加上，否则数据卷挂载失败。因为CentOS7安全模块会比之前系统版本加强，不安全的会先禁止，所以目录挂载的情况被默认为不安全的行为，在SELinux里面挂载目录被禁止掉了，如果要开启，我们一般使用--privileged=true命令，扩大容器的权限解决挂载目录没有权限的问题，也即使用该参数，container内的root拥有真正的root权限，否则，container内的
root只是外部的一个普通用户权限。
什么是容器卷?
容器卷就是目录或文件，存在于一个或多个容器中，由docker挂载到容器，但不属于联合文件系统，因此能够绕过Union File System提供一些用于持续存储或共享数据的特性。卷的设计目的就是数据的持久化，完全独立于容器的生存周期，因此Docker不会在容器删除时删除其挂载的数据卷。
数据卷能干嘛?
Docker容器产生的数据，如果不备份，那么当容器实例删除后，容器内的数据自然也就没有了。为了能保存数据在docker中我们使用卷。
数据卷的特点：
1：数据卷可在容器之间共享或重用数据
2：卷中的更改可以直接实时生效
3：数据卷中的更改不会包含在镜像的更新中
4：数据卷的生命周期一直持续到没有容器使用它为止
2.数据卷的基本案例
我们还是以ubuntu容器为例，在宿主机和容器之间添加数据卷。添加数据卷的命令是:
docker run -it --privileged=true -v /宿主机绝对路径目录:/容器内目录 镜像名
[root@shjava101 ~]# docker run -it --privileged=true -v /tmp/hostData:/tmp/dockerData1 ubuntu /bin/bash此时我们查看宿主机目录：
[root@shjava101 /]# cd /tmp
[root@shjava101 hostData]# pwd
/tmp/hostData 我们发现宿主机之前不存在的目录，现在已经自动创建了。
我们再看看容器中的目录:
root@1c88215ff319:/# cd /tmp/dockerData1/
root@1c88215ff319:/tmp/dockerData1# ll
total 0现在我们在宿主机对应的目录里面创建一个文件。
[root@shjava101 hostData]# touch a.txt我们回到容器目录查看：
root@1c88215ff319:/tmp/dockerData1# ls
a.txt接下来我们在容器中再创建一个文件：
root@1c88215ff319:/tmp/dockerData1# touch b.txt我们回到宿主机查看：
[root@shjava101 hostData]# ll
total 0
-rw-r--r--. 1 root root 0 Dec 25 16:51 a.txt
-rw-r--r--. 1 root root 0 Dec 25 16:52 b.txt我们发现只要宿主机和容器之间的目录形成挂载关系，不管是容器内数据发生变化，还是宿主机内部数据发生变化，都会被另一方即时同步！
如果我们把容器停止掉然后在宿主机修改数据呢？
[root@shjava101 ~]# docker stop 1c88215ff319 # 停止容器
1c88215ff319我们在宿主机对应的目录里面再创建一个文件。
[root@shjava101 hostData]# touch c.txt我们再次启动容器，进入对应目录，查看文件:
[root@shjava101 ~]# docker exec -it 1c88215ff319 /bin/bash
root@1c88215ff319:/# cd /tmp/dockerData1/
root@1c88215ff319:/tmp/dockerData1# ll
total 0
drwxr-xr-x. 2 root root 45 Dec 25 08:58 ./
drwxrwxrwt. 1 root root 25 Dec 25 08:47 ../
-rw-r--r--. 1 root root 0 Dec 25 08:51 a.txt
-rw-r--r--. 1 root root 0 Dec 25 08:52 b.txt
-rw-r--r--. 1 root root 0 Dec 25 08:58 c.txt 我们发现即时容器停止了，当再次启动容器之后，文件依然还是可以同步。
如何查看据卷是否挂载成功? docker inspect 容器id
[root@shjava101 ~]# docker inspect 1c88215ff319 
上面的挂载，默认在容器内部的目录都可以进行读写操作。如果我们只想在容器内部进行读操作呢? 我们需要加上:ro标识
[root@shjava101 ~]# docker run -it --privileged=true -v /tmp/hostData:/tmp/dockerData1:ro ubuntu /bin/bashroot@f4bce15fcc4e:/# cd /tmp/dockerData1/
root@f4bce15fcc4e:/tmp/dockerData1# touch d.txt # 创建文件失败
touch: cannot touch 'd.txt': Read-only file system此时如果宿主机写入内容，可以同步给容器内，容器可以读取到。
容器的数据卷还可以被继承和共享。
我们先启动一个ubuntu的容器1:
[root@shjava101 ~]# docker run -it --privileged=true -v /tmp/hostData:/tmp/data --name=u1 ubuntu /bin/bash
root@f3f75fcb55d4:/#我们再启动容器2继承容器1的卷规则：
语法格式：docker run -it --privileged=true --volumes-from 父类 --name u2 ubuntu
[root@shjava101 hostData]# docker run -it --privileged=true -- volumes-from u1 --name=u2 ubuntu /bin/bash
root@1e8776ef5733:/# cd /tmp/data/
root@1e8776ef5733:/tmp/data#我们发现容器2有和容器1一样的数据卷，因为容器1的数据卷目录被容器2继承了。
我们在容器1里面定义一个文件:
root@f3f75fcb55d4:/# cd /tmp/data/
root@f3f75fcb55d4:/# touch abc.txt我们在容器2里面查看这个文件：
root@1e8776ef5733:/tmp/data# ll
total 0
drwxr-xr-x. 2 root root 60 Dec 25 09:29 ./
drwxrwxrwt. 1 root root 18 Dec 25 09:25 ../
-rw-r--r--. 1 root root 0 Dec 25 09:29 abc.txt我们发现容器2也存在这个文件了，这样我们就实现了不同容器之间的数据共享。
七.Docker中常见软件的常规安装
1.安装tomcat
第一步：搜索镜像
[root@shjava101 ~]# docker search tomcat/
第二步：拉取镜像
[root@shjava101 ~]# docker pull tomcat
第三步：docker images查看是否有拉取到的tomcat
[root@shjava101 ~]# docker images tomcat
REPOSITORY TAG IMAGE ID CREATED SIZE
tomcat latest fb5657adc892 12 months ago 680MB
第四步：使用tomcat镜像创建容器实例(也叫运行镜像)
[root@shjava101 ~]# docker run -d -p 8080:8080 --name t1 tomcat
[root@shjava101 ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED
STATUS PORTS NAMES
7dd763fc2bcd tomcat "catalina.sh run" 4 seconds ago Up 3
seconds 0.0.0.0:8080->8080/tcp, :::8080->8080/tcp t1此时我们访问8080：
为什么会出现404？我们的tomcat不是已经成功启动了吗？这是因为我们拉取的是最新的tomcat镜像，最新的tomcat对首页访问的规则做了修改。
所以我们先进入tomcat容器的内部：
[root@shjava101 ~]# docker exec -it 7dd763fc2bcd /bin/bash # 进入容器的内部
root@7dd763fc2bcd:/usr/local/tomcat# ls -l # 查看容器内部的文件
我们进入webapps目录：
root@7dd763fc2bcd:/usr/local/tomcat# cd webapps
root@7dd763fc2bcd:/usr/local/tomcat/webapps# ls -l
total 0 我们发现这里面是空的，这也是我们为什么不能访问tomcat首页的原因。
真正有货的是webapps.dist目录：
root@7dd763fc2bcd:/usr/local/tomcat# cd webapps.dist/
root@7dd763fc2bcd:/usr/local/tomcat/webapps.dist# ls -l
total 4
drwxr-xr-x. 3 root root 223 Dec 22 2021 ROOT
drwxr-xr-x. 15 root root 4096 Dec 22 2021 docs
drwxr-xr-x. 7 root root 99 Dec 22 2021 examples
drwxr-xr-x. 6 root root 79 Dec 22 2021 host-manager
drwxr-xr-x. 6 root root 114 Dec 22 2021 manager 所以我们现在把已经存在的webapps目录删除，然后将webapps.dist目录重命名为
webapps目录。
root@7dd763fc2bcd:/usr/local/tomcat# rm -rf webapps
root@7dd763fc2bcd:/usr/local/tomcat# mv webapps.dist/ webapps接下来我们再访问tomcat首页：
我们发现访问成功。
但是这样进入容器修改容器的规则很麻烦，我们可不可以安装一个免修改的tomcat镜像呢？是可以的。
[root@shjava101 ~]# docker pull billygoo/tomcat8-jdk8 # 下载一个tomcat8镜像
[root@shjava101 ~]# docker run -d -p 8081:8080 --name mytomcat8
billygoo/tomcat8-jdk8我们访问tomcat的首页：
2. 安装mysql
2.1简单版本安装
第一步：拉取镜像
[root@shjava101 ~]# docker pull mysql:5.7
第二步：查看镜像是否拉取成功
[root@shjava101 ~]# docker images mysql:5.7
REPOSITORY TAG IMAGE ID CREATED SIZE
mysql 5.7 c20987f18b13 12 months ago 448MB
第三步：运行镜像
运行mysql的镜像的命令是什么？我们进入https://hub.docker.com/ 搜索mysql镜像 
[root@shjava101 ~]# docker run -p 3307:3306 -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7一定要保证linux里面没有运行的mysql，如果有的话，端口映射3307。否则会报异常。
[root@shjava101 ~]# docker ps
CONTAINER ID IMAGE COMMAND
CREATED STATUS PORTS
NAMES
1815bbc70d06 mysql:5.7 "docker-entrypoint.s…"
53 seconds ago Up 51 seconds 33060/tcp, 0.0.0.0:3307-
>3306/tcp, :::3307->3306/tcp recursing_allen
第四步：进入容器内部,登录mysql数据库
[root@shjava101 ~]# docker exec -it 1815bbc70d06 /bin/bash
root@1815bbc70d06:/# mysql -u root -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 2
Server version: 5.7.36 MySQL Community Server (GPL)
Copyright (c) 2000, 2021, Oracle and/or its affiliates.
Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.
Type 'help;' or '\h' for help. Type '\c' to clear the current
input statement.
mysql>
mysql> show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| mysql |
| performance_schema |
| sys |
+--------------------+
4 rows in set (0.03 sec)
第五步：使用sqlYog工具来连接mysql
我们发现连接成功。
目前运行的容器有没有什么问题？首先我们在运行容器的时候，没有指定字符编码集，可能会存在插入中文出现乱码的情况，还有就是如果我们删除容器之后，容器里面存在的数据怎么办？所以我们需要对我们安装步骤进行优化。
首先我们删除之前运行的mysql容器:
[root@shjava101 ~]# docker stop 1815bbc70d06 # 停止mysql容器
1815bbc70d06
[root@shjava101 ~]# docker rm -f 1815bbc70d06 # 删除mysql容器
1815bbc70d062.2 实战版本安装
第一步：运行mysql容器
[root@shjava101 /]# docker run -d -p 3307:3306 --privileged=true
-v /opt/mysql/log:/var/log/mysql -v
/opt/mysql/data:/var/lib/mysql -v
/opt/mysql/conf:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=123456
--name mysql mysql:5.7
第二步：新建my.cnf
[root@shjava101 /]# cd /opt/mysql/conf/
[root@shjava101 conf]# vim my.cnf
我们编辑：
[client]
default_character_set=utf8
[mysqld]
collation_server = utf8_general_ci
character_set_server = utf8
第三步：重新启动mysql容器实例再重新进入并查看字符编码
由于修改了配置，我们最好将容器重新启动一下：
[root@shjava101 conf]# docker restart 0a992c086f8e
0a992c086f8e
第四步：进入容器，并登陆mysql数据库
[root@shjava101 conf]# docker exec -it 0a992c086f8e /bin/bash
root@0a992c086f8e:/# mysql -u root -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 2
Server version: 5.7.36 MySQL Community Server (GPL)
Copyright (c) 2000, 2021, Oracle and/or its affiliates.
Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.
Type 'help;' or '\h' for help. Type '\c' to clear the current
input statement.
mysql>
我们查看mysql数据库的字符编码集：
mysql> show variables like 'character%';
+--------------------------+----------------------------+
| Variable_name | Value |
+--------------------------+----------------------------+
| character_set_client | utf8 |
| character_set_connection | utf8 |
| character_set_database | utf8 |
| character_set_filesystem | binary |
| character_set_results | utf8 |
| character_set_server | utf8 |
| character_set_system | utf8 |
| character_sets_dir | /usr/share/mysql/charsets/ |
+--------------------------+----------------------------+
8 rows in set (0.00 sec)
第五步：创建数据表，插入数据
我们在mysql里面创建数据表，并插入数据：
我们进入数据卷挂载的目录查看数据是否存在：
[root@shjava101 mysql]# cd /opt/mysql/data
我们发现我们创建的数据成功的保存到数据卷对应的挂载目录了。
3.安装redis
3.1简单安装
第一步：拉取镜像
[root@shjava101 /]# docker pull redis:6.0.8
第二步：查看镜像是否存在
[root@shjava101 /]# docker images redis:6.0.8
REPOSITORY TAG IMAGE ID CREATED SIZE
redis 6.0.8 16ecd2772934 2 years ago 104MB
第三步：运行镜像
[root@shjava101 /]# docker run -d -p 6379:6379 redis:6.0.8
5d46714dbbd53644af02ec77954a6d9c5fc593443be5cc76d2631fc826db2388
第四步：进入容器内部
[root@shjava101 /]# docker exec -it 5d46714dbbd5 /bin/bash
root@5d46714dbbd5:/data# ls -l
total 0
root@5d46714dbbd5:/data# redis-cli
127.0.0.1:6379> set username eric
OK
127.0.0.1:6379> get username
"eric"
127.0.0.1:6379>
我们发现可以正常运行，并可以插入数据。
但是现在存在的问题就是当容器删除之后，redis容器里面的数据也不会保存。所以我们在运行容器的时候，需要使用数据卷进行挂载。
我们先退出并删除容器:
root@5d46714dbbd5:/data# exit
exit
[root@shjava101 /]# docker rm -f 5d46714dbbd5
5d46714dbbd53.2实战版安装
第一步：我们在宿主机下面创建目录
[root@shjava101 /]# cd /opt
[root@shjava101 /]# mkdir -p app/redis
第二步：将一个redis.conf文件模板拷贝进/opt/app/redis目录下
[root@shjava101 opt]# cp redis.conf /opt/app/redis/
[root@shjava101 opt]# cd /opt/app/redis
[root@shjava101 redis]# ll
total 92
-rw-r--r--. 1 root root 92242 Dec 29 21:33 redis.conf
第三步：/opt/app/redis目录下修改redis.conf文件
允许redis外部连接
daemonize no
将daemonize yes注释起来或者 daemonize no设置，因为该配置和docker run中-d参数冲突，会导致容器一直启动失败
开启redis数据持久化 appendonly yes
第四步：使用redis6.0.8镜像创建容器(也叫运行镜像)
[root@shjava101 redis]# docker run -p 6379:6379 --name myredis --privileged=true -v
/opt/app/redis/redis.conf:/etc/redis/redis.conf -v
/opt/app/redis/data:/data -d redis:6.0.8 redis-server
/etc/redis/redis.conf
1e41c9e23d443ad9f558f723d396e4cb44ec349f481428321137889ac4b8185c
第五步：测试客户端
root@1e41c9e23d44:/data# redis-cli
127.0.0.1:6379> set username eric
OK
127.0.0.1:6379> get username
"eric"4.安装mysql主从复制
4.1主从复制的原理
什么是主从复制:
主从复制，是用来建立一个和主数据库完全一样的数据库环境，称为从数据库；主数据库一般是准实时的业务数据库
主从复制的作用（好处，或者说为什么要做主从）:
1、做数据的热备，作为后备数据库，主数据库服务器故障后，可切换到从数据库继续工作,避免数据丢失。
2、架构的扩展。业务量越来越大，I/O访问频率过高，单机无法满足，此时做多库的存储,降低磁盘I/O访问的频率，提高单个机器的I/O性能。
3、读写分离，使数据库能支撑更大的并发。在报表中尤其重要。由于部分报表sql语句非常的慢，导致锁表，影响前台服务。如果前台使用master，报表使用slave，那么报表sql将不会造成前台锁，保证了前台速度。
主从复制的原理（重中之重，面试必问）：
1.数据库有个bin-log二进制文件，记录了所有sql语句。
2.我们的目标就是把主数据库的bin-log文件的sql语句复制过来。
3.让其在从数据的relay-log重做(中继)日志文件中再执行一次这些sql语句即可。
4.下面的主从配置就是围绕这个原理配置
5.具体需要三个线程来操作：
5.1 binlog输出线程:每当有从库连接到主库的时候，主库都会创建一个线程然后发送binlog内容到从库。在从库里，当复制开始的时候，从库就会创建两个线程进行处理：
5.2 从库I/O线程:当START SLAVE语句在从库开始执行之后，从库创建一个I/O线程，该线程连接到主库并请求主库发送binlog里面的更新记录到从库上。从库I/O线程读取主库的binlog输出线程发送的更新并拷贝这些更新到本地文件，其中包括relay log文件。
5.3 从库的SQL线程:从库创建一个SQL线程，这个线程读取从库I/O线程写到relaylog的更新事件并执行。
可以知道，对于每一个主从复制的连接，都有三个线程。拥有多个从库的主库为每一个连接到主库的从库创建一个binlog输出线程，每一个从库都有它自己的I/O线程和SQL线程。
主从复制如图：
解读主从复制的流程：
步骤一：主库db的更新事件(update、insert、delete)被写到binlog
步骤二：从库发起连接，连接到主库
步骤三：此时主库创建一个binlog dump thread线程，把binlog的内容发送到从库
步骤四：从库启动之后，创建一个I/O线程，读取主库传过来的binlog内容并写入到relay log.
步骤五：还会创建一个SQL线程，从relay log里面读取内容，从Exec_Master_Log_Pos位置开始执行读取到的更新事件，将更新内容写入到slave的db.
主从复制的方式
一主一从
主主复制
一主多从—扩展系统读取的性能，因为读是在从库读取的；
多主一从—5.7开始支持
联级复制
4.2 主从复制搭建的步骤
第一步：新建主服务器容器实例3307
[root@shjava101 ~]# docker run -p 3307:3306 --name mysql-master \
> -v /mydata/mysql-master/log:/var/log/mysql \
> -v /mydata/mysql-master/data:/var/lib/mysql \
> -v /mydata/mysql-master/conf:/etc/mysql \
> -e MYSQL_ROOT_PASSWORD=root \
> -d mysql:5.7
be8a585a72b3639e532d77277ad9cc6ffe608e0a354598d265edba6def88a9a9
[root@shjava101 ~]# docker ps # 查看mysql容器是否运行
CONTAINER ID IMAGE COMMAND CREATED
STATUS PORTS
NAMES
be8a585a72b3 mysql:5.7 "docker-entrypoint.s…" 12 seconds
ago Up 7 seconds 33060/tcp, 0.0.0.0:3307->3306/tcp, :::3307-
>3306/tcp mysql-master
第二步：进入/mydata/mysql-master/conf目录下新建my.cnf
我们使用vim my.cnf命令，创建一个mysql配置文件，然后输入：
[mysqld]
## 设置server_id，同一局域网中需要唯一
server_id=101
## 指定不需要同步的数据库名称
binlog-ignore-db=mysql
## 开启二进制日志功能
log-bin=mall-mysql-bin
## 设置二进制日志使用内存大小（事务）
binlog_cache_size=1M
## 设置使用的二进制日志格式（mixed,statement,row）
binlog_format=mixed
## 二进制日志过期清理时间。默认值为0，表示不自动清理。
expire_logs_days=7
## 跳过主从复制中遇到的所有错误或指定类型的错误，避免slave端复制中断。
## 如：1062错误是指一些主键重复，1032错误是因为主从数据库数据不一致
slave_skip_errors=1062
[root@shjava101 ~]# cd /mydata/mysql-master/conf
[root@shjava101 conf]# vim my.cnf
然后输入以上配置内容：
第三步：修改完配置后重启master实例
由于修改了配置文件信息，我们需要重启mysql容器
[root@shjava101 conf]# docker restart mysql-master
mysql-master
第四步：进入mysql-master容器
进入mysql数据库容器，登录mysql数据库
[root@shjava101 conf]# docker exec -it mysql-master /bin/bash
root@be8a585a72b3:/# mysql -u root -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 2
Server version: 5.7.36-log MySQL Community Server (GPL)
Copyright (c) 2000, 2021, Oracle and/or its affiliates.
Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.
Type 'help;' or '\h' for help. Type '\c' to clear the current
input statement.
第五步：master容器实例内创建数据同步用户
mysql> CREATE USER 'slave'@'%' IDENTIFIED BY '123456'; # 创建数据同步的用户
Query OK, 0 rows affected (0.19 sec)
mysql> GRANT REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO
'slave'@'%'; # 对用户进行授权操作
Query OK, 0 rows affected (0.00 sec)
第六步：新建从服务器容器实例3308
[root@shjava101 conf]# docker run -p 3308:3306 --name mysql-slave\
> -v /mydata/mysql-slave/log:/var/log/mysql \
> -v /mydata/mysql-slave/data:/var/lib/mysql \
> -v /mydata/mysql-slave/conf:/etc/mysql \
> -e MYSQL_ROOT_PASSWORD=root \
> -d mysql:5.7
2fd617d42f907f30c2cb468d6f4552987f406ab25d6fa52ba1545e4336354c94
第七步：进入/mydata/mysql-slave/conf目录下新建my.cnf
使用命令vim my.cnf新建my.cnf,并准备对应的配置文件内容
[mysqld]
## 设置server_id，同一局域网中需要唯一
server_id=102
## 指定不需要同步的数据库名称
binlog-ignore-db=mysql
## 开启二进制日志功能，以备Slave作为其它数据库实例的Master时使用
log-bin=mall-mysql-slave1-bin
## 设置二进制日志使用内存大小（事务）
binlog_cache_size=1M
## 设置使用的二进制日志格式（mixed,statement,row）
binlog_format=mixed
## 二进制日志过期清理时间。默认值为0，表示不自动清理。
expire_logs_days=7
## 跳过主从复制中遇到的所有错误或指定类型的错误，避免slave端复制中断。
## 如：1062错误是指一些主键重复，1032错误是因为主从数据库数据不一致
slave_skip_errors=1062
第八步：修改完配置后重启slave实例
[root@shjava101 conf]# docker restart mysql-slave
mysql-slave
第九步：在主数据库中查看主从同步状态
在master主机上查看主从同步的状态：
mysql> show master status;
第十步：进入mysql-slave容器
进入mysql-slave容器，然后登陆数据库：
[root@shjava101 conf]# docker exec -it mysql-slave /bin/bash
root@2fd617d42f90:/# mysql -uroot -proot
mysql: [Warning] Using a password on the command line interface
can be insecure.
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 2
Server version: 5.7.36-log MySQL Community Server (GPL)
Copyright (c) 2000, 2021, Oracle and/or its affiliates.
Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.
Type 'help;' or '\h' for help. Type '\c' to clear the current
input statement.
mysql>
第十一步：在从数据库中配置主从复制
我们在从机上完成主从关系的配置：
具体语法如下：
change master to master_host='宿主机ip', master_user='slave',
master_password='123456', master_port=3307,
master_log_file='mall-mysql-bin.000001', master_log_pos=617,
master_connect_retry=30;
我们在从机上执行以上命令：
mysql> change master to master_host='192.168.10.145',
master_user='slave', master_password='123456', master_port=3307,
master_log_file='mall-mysql-bin.000001', master_log_pos=617,
master_connect_retry=30;
Query OK, 0 rows affected, 2 warnings (0.02 sec)
master_log_pos参数的值一定要和主机中的Position参数的值保持一致！
配置主从复制关系的参数说明:
master_host：主数据库的IP地址；
master_port：主数据库的运行端口；
master_user：在主数据库创建的用于同步数据的用户账号；
master_password：在主数据库创建的用于同步数据的用户密码；
master_log_file：指定从数据库要复制数据的日志文件，通过查看主数据的状态，获取File参数；
master_log_pos：指定从数据库从哪个位置开始复制数据，通过查看主数据的状态，获取Position参数；
master_connect_retry：连接失败重试的时间间隔，单位为秒。
第十二步：在从数据库中查看主从同步状态
mysql> show slave status \G; 
第十三步：在从数据库中开启主从同步
mysql> start slave;
Query OK, 0 rows affected (0.04 sec) 第十四步：查看从数据库状态发现已经同步
在从数据库执行show slave status \G;命令
如果出现两个yes，说明主从复制成功。
第十五步：测试主从复制效果
在主机创建数据库，数据表
mysql> create database mysql_db;
Query OK, 1 row affected (0.00 sec)
mysql> use mysql_db;
Database changed
mysql> create table account(id int,name varchar(20),money
double);
Query OK, 0 rows affected (0.01 sec)
mysql> insert into account(id,name,money) values(1,'eric',100.0);
Query OK, 1 row affected (0.01 sec)
mysql> select * from account;
+------+------+-------+
| id | name | money |
+------+------+-------+
| 1 | eric | 100 |
+------+------+-------+
1 row in set (0.00 sec)在从数据库查看数据是否同步
5. 分布式缓存
5.1哈希取余分区
2亿条记录就是2亿个k,v，我们单机不行必须要分布式多机，假设有3台机器构成一个集群，用户每次读写操作都是根据公式：
hash(key) % N个机器台数，计算出哈希值，用来决定数据映射到哪一个节点上。
优点：
简单粗暴，直接有效，只需要预估好数据规划好节点，例如3台、8台、10台，就能保证一段时间的数据支撑。使用Hash算法让固定的一部分请求落到同一台服务器上，这样每台服务器固定处理一部分请求（并维护这些请求的信息），起到负载均衡+分而治之的作用。
缺点：
原来规划好的节点，进行扩容或者缩容就比较麻烦了额，不管扩缩，每次数据变动导致节点有变动，映射关系需要重新进行计算，在服务器个数固定不变时没有问题，如果需要弹性扩容或故障停机的情况下，原来的取模公式就会发生变化：Hash(key)/3会变成Hash(key) /?。此时地址经过取余运算的结果将发生很大变化，根据公式获取的服务器也会变得不可控。某个redis机器宕机了，由于台数数量变化，会导致hash取余全部数据重新洗牌。
5.2一致性哈希算法分区
什么是一致性哈希算法:
一致性哈希算法在1997年由麻省理工学院中提出的，设计目标是为了解决分布式缓存数据变动和映射问题，某个机器宕机了，分母数量改变了，自然取余数不OK了。提出一致性Hash解决方案。目的是当服务器个数发生变动时，尽量减少影响客户端到服务器的映射关系
如何构建一致性哈希算法分区:
步骤1：构建一致性哈希环
一致性哈希算法必然有个hash函数并按照算法产生hash值，这个算法的所有可能哈希值会构成一个全量集，这个集合可以成为一个hash空间[0,2^32-1]，这个是一个线性空间，但是在算法中，我们通过适当的逻辑控制将它首尾相连(0 = 2^32),这样让它逻辑上形成了一个环形空间。
它也是按照使用取模的方法，前面笔记介绍的节点取模法是对节点（服务器）的数量进行取模。而一致性Hash算法是对2^32取模，简单来说，一致性Hash算法将整个哈希值空间组织成一个虚拟的圆环，如假设某哈希函数H的值空间为0-2^32-1（即哈希值是一个32位无符号整形），整个哈希环如下图：整个空间按顺时针方向组织，圆环的正上方的点代表0，0点右侧的第一个点代表1，以此类推，2、3、4、……直到2^32-1，也就是说0点左侧的第一个点代表2^32-1， 0和2^32-1在零点中方向重合，我们把这个由2^32个点组成的圆环称为Hash环。
步骤2：服务器IP节点映射
将集群中各个IP节点映射到环上的某一个位置。将各个服务器使用Hash进行一个哈希，具体可以选择服务器的IP或主机名作为关键字进行哈希，这样每台机器就能确定其在哈希环上的位置。假如4个节点NodeA、B、C、D，经过IP地址的哈希函数计算(hash(ip))，使用IP地址哈希后在环空间的位置如下：
步骤3:key落到服务器的落键规则
当我们需要存储一个kv键值对时，首先计算key的hash值，hash(key)，将这个key使用相同的函数Hash计算出哈希值并确定此数据在环上的位置，从此位置沿环顺时针“行走”，第一台遇到的服务器就是其应该定位到的服务器，并将该键值对存储在该节点上。
如我们有Object A、Object B、Object C、Object D四个数据对象，经过哈希计算后，在环空间上的位置如下：根据一致性Hash算法，数据A会被定为到Node A上，B被定为到Node B上，C被定为到Node C上，D被定为到Node D上。
一致性哈希算法优缺点
1.优点：
容错性：
假设Node C宕机，可以看到此时对象A、B、D不会受到影响，只有C对象被重定位到Node D。一般的，在一致性Hash算法中，如果一台服务器不可用，则受影响的数据仅仅是此服务器到其环空间中前一台服务器（即沿着逆时针方向行走遇到的第一台服务器）之间数据，其它不会受到影响.简单说，就是C挂了，受到影响的只是B、C之间的数据，并且这些数据会转移到D进行存储。
扩展性:
数据量增加了，需要增加一台节点NodeX，X的位置在A和B之间，那受到影响的也就是A到X之间的数据，重新把A到X的数据录入到X上即可，不会导致hash取余全部数据重新洗牌。
2.缺点
Hash环的数据倾斜问题
一致性Hash算法在服务节点太少时，容易因为节点分布不均匀而造成数据倾斜（被缓存的对象大部分集中缓存在某一台服务器上）问题，例如系统中只有两台服务器：
5.3哈希槽分区
为什么出现:
主要是为了解决一致性哈希算法出现的数据倾斜问题。哈希槽实质就是一个数组，数组[0,2^14 -1]形成hash slot空间。
能干什么:
解决均匀分配的问题，在数据和节点之间又加入了一层，把这层称为哈希槽（slot），用于管理数据和节点之间的关系，现在就相当于节点上放的是槽，槽里放的是数据。
哈希槽的原理:
Redis 集群中内置了 16384 个哈希槽，redis 会根据节点数量大致均等的将哈希槽映射到不同的节点。当需要在 Redis 集群中放置一个 key-value时，redis 先对 key 使用 crc16 算法算出一个结果，然后把结果对 16384 求余数，这样每个 key 都会对应一个编号在 0-16383 之间的哈希槽，也就是映射到某个节点上。如下代码，key之A、B在Node2， key之C落在Node3上。
6. 3主3从redis集群搭建
6.1使用docker搭建redis集群
启动6台redis实例
[root@shjava101 ~]# docker run -d --name redis-node-1 --net host--privileged=true -v /data/redis/share/redis-node-1:/data
redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6381
7411fe90823cc6badd1914ea278fc4bc222990b531ee0ecd8b67e85c4ae89869
[root@shjava101 ~]# docker run -d --name redis-node-2 --net host--privileged=true -v /data/redis/share/redis-node-2:/data
redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6382
0abb93bcd630a9a8d474e40760fc4c4f3b43891422100fa32945f133f89a2354
[root@shjava101 ~]# docker run -d --name redis-node-3 --net host--privileged=true -v /data/redis/share/redis-node-3:/data
redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6383
6ba74f263a87e34b94a7d7634fd996528930b4c7a1019a04ceca04359dcc159c
[root@shjava101 ~]# docker run -d --name redis-node-4 --net host--privileged=true -v /data/redis/share/redis-node-4:/data
redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6384
71b9d2fa27fa3f198c0d8941643833b28fee90fa668e1b4f3bed993a9ef15f20
[root@shjava101 ~]# docker run -d --name redis-node-5 --net host--privileged=true -v /data/redis/share/redis-node-5:/data
redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6385
398c66d10574d2a37c5a5028c32c0cb95bb11f85a778f46af62497f0c0921c8d
[root@shjava101 ~]# docker run -d --name redis-node-6 --net host--privileged=true -v /data/redis/share/redis-node-6:/data
redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6386
0b2402941910e3d7efa03dab4b8f793218f6c23d09af78b66267628fbadac3dc启动之后查看容器是否启动
[root@shjava101 ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED
STATUS PORTS NAMES
0b2402941910 redis:6.0.8 "docker-entrypoint.s…" 34 seconds
ago Up 33 seconds redis-node-6
398c66d10574 redis:6.0.8 "docker-entrypoint.s…" 41 seconds
ago Up 40 seconds redis-node-5
71b9d2fa27fa redis:6.0.8 "docker-entrypoint.s…" 48 seconds
ago Up 47 seconds redis-node-4
6ba74f263a87 redis:6.0.8 "docker-entrypoint.s…" 54 seconds
ago Up 53 seconds redis-node-3
0abb93bcd630 redis:6.0.8 "docker-entrypoint.s…" About a
minute ago Up About a minute redis-node-2
7411fe90823c redis:6.0.8 "docker-entrypoint.s…" About a
minute ago Up About a minute redis-node-1 
进入容器redis-node-1并为6台机器构建集群关系
[root@shjava101 ~]# docker exec -it redis-node-1 /bin/bash # 进入1号容器内部
接下来我们构建主从关系：
root@shjava101:/data# redis-cli --cluster create 192.168.10.145:6381 192.168.10.145:6382 192.168.10.145:6383 192.168.10.145:6384 192.168.10.145:6385 192.168.10.145:6386 --cluster-replicas 1注意：--cluster-replicas 1 表示为每个master创建一个slave节点
执行之后如下：
我们输入yes，表示同意上面的配置：
查看集群状态
我们随便去连接一台redis服务，比如连接6381
root@shjava101:/data# redis-cli -p 6381
127.0.0.1:6381> cluster info # 查看集群状态 
我们也可以使用cluster nodes查看集群节点状态：
127.0.0.1:6381> cluster nodes 
6.2 在集群状态下存储数据
现在我们在集群的模式下面，存储数据。
127.0.0.1:6381> set k1 v1
(error) MOVED 12706 192.168.10.145:6383我们发现现在存储数据失败，为什么？因为我们在6381机器上进行数据存储，但是落在的哈希槽位于6383，超过了目前6381机器哈希槽的范围。所以我们在在连接redis的时候加上-c参数。
127.0.0.1:6381> quit
root@shjava101:/data# redis-cli -p 6381 -c
127.0.0.1:6381> set k1 v1
-> Redirected to slot [12706] located at 192.168.10.145:6383
OK我们还有一个命令也可以查看集群节点的状态：
root@shjava101:/data# redis-cli --cluster check 192.168.10.145:6381 
6.3 redis集群容错切换迁移
我们先查看运行的redis容器：
现在我们停掉我们的6381机器
[root@shjava101 ~]# docker stop redis-node-1
redis-node-1再次查看运行的redis容器：
现在我们发现只有5台运行的redis了。
接下来我们进入到redis2号机器的内部容器
[root@shjava101 ~]# docker exec -it redis-node-2 /bin/bash
root@shjava101:/data# redis-cli -p 6382 -c
127.0.0.1:6382> cluster nodes查看集群节点信息：
我们发现6386以前是从机，现在变成了主机，完成了集群故障迁移。
大家思考一个问题，如果6381重新启动之后，目前redis集群形成的主从关系会不会发生变化？
我们在另外一个xshell窗口先启动redis6381这台机器：
[root@shjava101 ~]# docker start redis-node-1
redis-node-1接下来我们再去查看集群的节点关系：
我们发现6381现在变成了从机，原来的主机状态依然没有发生变化。
7.redis集群扩容
将现在的3主3从扩容成4主4从
新建6387、6388两个节点+新建后启动+查看是否8节点
[root@shjava101 ~]# docker run -d --name redis-node-7 --net host
--privileged=true -v /data/redis/share/redis-node-7:/data
redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6387
c51042dee9203ac07df202daa23a46f33b2d930b5d1e8a8e94c7193e1a243e4e
[root@shjava101 ~]# docker run -d --name redis-node-8 --net host
--privileged=true -v /data/redis/share/redis-node-8:/data
redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6388
f5c92d0af154f471160c2664b947a0544c911790beba978a20ca388cca3125f7查看容器状态：
现在我们看到，8台redis已经成功启动。
进入6387容器实例内部
[root@shjava101 ~]# docker exec -it redis-node-7 /bin/bash
root@shjava101:/data#将新增的6387节点(空槽号)作为master节点加入原集群
[root@shjava101 ~]# redis-cli --cluster add-node 192.168.10.145:6387 192.168.10.145:63816387 就是将要作为master新增节点
6381 就是原来集群节点里面的领路人，相当于6387找到6381这个领路人从而找到组织加入集群
执行之后，结果如下：
检查集群情况
root@shjava101:/data# redis-cli --cluster check
192.168.10.145:6381 
我们发现6387这台机器暂时没有槽位，也没有从机。
重新分派槽号:
命令:redis-cli --cluster reshard IP地址:端口号
root@shjava101:/data# redis-cli --cluster reshard 192.168.10.145:6381
接下来我们要把哈希槽分配给6387这台机器：
接下来输入all：
我们最后输入yes，保存以上配置信息。
再次检查集群状态
root@shjava101:/data# redis-cli --cluster check 192.168.10.145:6381 
我们发现6387号机器以经分配了哈希槽。
重新分配成本太高，所以前3家各自匀出来一部分，从6381/6382/6383三个旧节点分别匀出1364个坑位给新节点6387
为主节点6387分配从节点6388
命令：redis-cli --cluster add-node ip:新slave端口 ip:新master端口 -- cluster-slave --cluster-master-id 新主机节点ID
root@shjava101:/data# redis-cli --cluster add-node 192.168.10.145:6388 192.168.10.145:6387 --cluster-slave -- cluster-master-id 94c80c2ef8d004f4462e42dd00b89d237c9dfc4d最后查看集群节点信息
root@shjava101:/data# redis-cli --cluster check 192.168.10.145:6381
8. redis集群缩容
需求：6387和6388下线
检查集群情况，获得6387 6388的节点ID
root@shjava101:/data# redis-cli --cluster check 192.168.10.145:6382 
删除从节点6388
命令：redis-cli --cluster del-node ip:从机端口 从机6388节点ID
root@shjava101:/data# redis-cli --cluster del-node 192.168.10.145:6388 3314c06b7b773b81bb4df47cb8ed6d44e8847684 
再次查看集群节点情况：
我们发现从节点由原来的4台变成了现在的3台，说明6388号从节点删除成功。
将6387的槽号清空，重新分配
我们将清出来的槽号都给6382。
root@shjava101:/data# redis-cli --cluster reshard 192.168.10.145:6381 
再次检查集群节点情况
root@shjava101:/data# redis-cli --cluster check 192.168.10.145:6381 
我们发现6387的哈希槽全部删除，并分配给6382了。
将6387删除
命令：redis-cli --cluster del-node ip:端口 6387节点ID
root@shjava101:/data# redis-cli --cluster del-node 192.168.10.145:6387 94c80c2ef8d004f4462e42dd00b89d237c9dfc4d 
最后再次查看节点信息
root@shjava101:/data# redis-cli --cluster check 192.168.10.145:6381
八. DockerFile
1.什么是DockerFile
什么是DockerFile?Dockerfile是用来构建Docker镜像的文本文件，是由一条条构建镜像所需的指令和参数构成的脚本。所以我们得知，DockerFile是用来构建Docker镜像的。
以前我们可以通过docker commit命令将一个容器重新打成一个新的镜像。但是在微服务中，我们可能需要配置很多参数，并且这些参数可能是实时动态变化的，而且微服务还需要和许多中间件之间建立联系。这个时候使用docker commit将微服务制作成镜像就不太方便了，这个时候docker file就可以解决问题。对于dockerfile的学习，我们可以参照官网：https://docs.docker.com/engine/refe
rence/builder/
那我们如何通过dockerFile构建镜像?我们只需要3个步骤即可：
编写Dockerfile文件
docker build命令构建镜像
docker run 镜像运行容器实例
2. DockerFile构建过程解析
2.1DockerFile基础知识
1. 每条保留字指令都必须为大写字母且后面要跟随至少一个参数。什么是保留字指令？我们可以在官网上查看(https://docs.docker.com/engine/reference/builder/)：
1. 指令按照从上到下，顺序执行。
2. #表示注释。
3. 每条指令都会创建一个新的镜像层并对镜像进行提交。
2.2Docker执行Dockerfile的大致流程
1. docker从基础镜像运行一个容器
2. 执行一条指令并对容器作出修改
3. 执行类似docker commit的操作提交一个新的镜像层
4. docker再基于刚提交的镜像运行一个新容器
5. 执行dockerfile中的下一条指令直到所有指令都执行完成
总结：
从应用软件的角度来看，Dockerfile、Docker镜像与Docker容器分别代表软件的三个不同阶段，
Dockerfile是软件的原材料
Docker镜像是软件的交付品
Docker容器则可以认为是软件镜像的运行态，也即依照镜像运行的容器实例Dockerfile面向开发，Docker镜像成为交付标准，Docker容器则涉及部署与运维，三者缺一不可，合力充当Docker体系的基石。
1. Dockerfile，需要定义一个Dockerfile，Dockerfile定义了镜像需要的一切东西。Dockerfile涉及的内容包括执行代码或者是文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行版、服务进程和内核进程(当应用进程需要和系统服务和内核进程打交道，这时需要考虑如何设计namespace的权限控制)等等;
2. Docker镜像，在用Dockerfile定义一个文件之后，docker build时会产生一个Docker镜像，当运行 Docker镜像时会真正开始提供服务;
3. Docker容器，容器是直接提供服务的。
2.3 DockerFile常用保留字指令
参考tomcat8的dockerfile入门：https://github.com/docker-library/tomcat/bl ob/master/8.5/jdk8/corretto-al2/Dockerfile
2.3.1FROM关键字
基础镜像，当前新镜像是基于哪个镜像的，指定一个已经存在的镜像作为模板，第一条必须是from。比如我们上图的tomcat镜像，第一句就是from amazoncorretto:8-a12-jdk.这句话的意思就是这个tomcat镜像是基于amazoncorretto:8-a12-jdk这个镜像制作的。
2.3.2MAINTAINER
描述镜像维护者的姓名和邮箱地址。
2.3.3RUN
容器构建的时候需要运行的命令。也就是dockerfile在构建的时候(build)需要执行的命令。运行命令的格式有两种。一种是shell格式，一种是exec格式。
shell格式:
RUN 命令行命令 等同于在终端操作的shell命令。
比如 RUN yum -y install vim. 就相当于在构建镜像的时候安装vim工具。
exec格式:
具体语法格式如下：
总结：RUN是在docker build的时候运行。
2.3.4 EXPOSE
当前容器对外暴露的端口。
2.3.5 WORKDIR
指定在创建容器后，终端默认登陆的进来工作目录，一个落脚点。我们以tomcat镜像为例，让我们启动运行一个tomcat容器之后，我们观察进入容器之后的默认目录：
[root@shjava101 ~]# docker run -it -p 8080:8080 tomcat /bin/bash
root@99d0a0da1a9f:/usr/local/tomcat# pwd
/usr/local/tomcat我们发现现在进入tomcat容器之后的默认目录就是/usr/local/tomcat。
2.3.6 ENV
用来在构建镜像过程中设置环境变量。这个环境变量可以在后续的任何RUN指令中使用，这就如同在命令前面指定了环境变量前缀一样；
也可以在其它指令中直接使用这些环境变量。我们以tomcat的环境变量为例：
ENV CATALINA_HOME /usr/local/tomcat。
WORKDIR $CATALINA_HOME。
这就证明了为什么tomcat容器运行之后的默认落脚点是/usr/local/tomcat。
2.3.7 USER
指定该镜像以什么样的用户去执行，如果都不指定，默认是root。一般我们都是以root用户去运行我们的镜像。
2.3.8 VOLUME
容器数据卷，用于数据保存和持久化工作。
2.3.9 ADD
将宿主机目录下的文件拷贝进镜像且会自动处理URL和解压tar压缩包。
2.3.10 COPY
类似ADD，拷贝文件和目录到镜像中。 将从构建上下文目录中 <源路径> 的文件/目录复制到新的一层的镜像内的 <目标路径> 位置
COPY src dest 或者
COPY ["src","dest"]
src:源文件或者源目录
dest:容器内的指定路径，该路径不用事先建好，路径不存在的话，会自动创建
2.3.11 CMD
指定容器启动后的要干的事情。CMD后面跟的指令格式和RUN类似，也有两种格式：
我们以tomcat容器为例，我们首先启动tomcat容器：
[root@shjava101 ~]# docker run -it -p 8080:8080 30ef4019761d发现如下效果：
我们发现启动tomcat容器的时候，显示了很多启动日志信息。为什么这样呢，就是因为tomcat的dockerfile里面的最后一句话：
CMD ["catalina.sh","run"]。也就是运行了catalina.sh命令。
需要注意的是： Dockerfile 中可以有多个 CMD 指令，但只有最后一个生效，CMD 会被 docker run 之后的参数替换。
这句话是什么意思呢？
我们以如下这条命令为例启动tomcat，我们在最后面加上了一句/bin/bash命令：
[root@shjava101 ~]# docker run -it -p 8080:8080 30ef4019761d /bin/bash此时我们发现，tomcat容器启动之后，相关的启动日志信息没有出现：
这就说明了catalina.sh命令没有运行，为什么 因为相当于使用CMD运行了/bin/bash命令，覆盖了catalina.sh命令。如下所示
CMD ["catalina.sh","run"]
CMD ["/bin/bash","run"]
最后一定要注意区分RUN和CMD命令的区别：
RUN命令是docker build(构建)的时候运行。CMD是docker run的时候运行。
2.3.12 ENTRYPOINT
也是用来指定一个容器启动时要运行的命令，它类似于 CMD 指令，但是ENTRYPOINT不会被docker run后面的命令覆盖， 而且这些命令行参数会被当作参数送给 ENTRYPOINT 指令指定的程序。
命令格式：
ENTRYPOINT可以和CMD一起用，一般是变参才会使用 CMD ，这里的 CMD 等于是在给 ENTRYPOINT 传参。当指定了ENTRYPOINT后，CMD的含义就发生了变化，不再是直接运行其命令而是将CMD的内容作为参数传递给ENTRYPOINT指令。
案例如下：假设已通过 Dockerfile 构建了 nginx:test 镜像：
| 是否传参 | 按照dockerfile编写执行 | 传参运行 |
| Docker命令 | docker run nginx:test | docker run nginx:test -c /etc/nginx/new.conf |
| 衍生出的实际命令 | nginx -c /etc/nginx/nginx.conf | nginx -c /etc/nginx/new.conf |
2.4DockerFile案例
需求：自定义镜像centos。要求Centos7镜像具备vim+ifconfig+jdk8
2.4.1前期准备工作
前期准备工作：准备centos7镜像
[root@shjava101 ~]# docker search centos
[root@shjava101 ~]# docker pull centos:7 
现在我们通过centos镜像来运行centos这个容器：
[root@shjava101 ~]# docker run -it 5d0da3dc9764 /bin/bash
[root@08f77f750842 /]# vim a.txt
bash: vim: command not found
[root@08f77f750842 /]# ifconfig
bash: ifconfig: command not found
[root@08f77f750842 /]# java -version
bash: java: command not found我们发现这个centos容器里面vim ifconfig 工具以及java8的环境都没有。因为我们现在运行的centos7容器只具备最基本的环境。我们需要自己进行相关功能的加强
2.4.2 编写dockerfile文件
第一步：我们新开一个命令窗口，新建一个文件夹myfile,并上传一个linux版本的jdk。
[root@shjava101 ~]# cd /
[root@shjava101 /]# mkdir myfile
[root@shjava101 /]# cd myfile/
[root@shjava101 myfile]# pwd
/myfile
[root@shjava101 myfile]# ll
total 185312
-rw-r--r--. 1 root root 189756259 Jan 22 21:06 jdk-8u161-linux-
x64.tar.gz
第二步：编写Dockerfile文件
在myfile目录下面，编写DockerFile文件，注意文件名称首字母一定要是大写的D
[root@shjava101 ~]# vim Dockerfile
并在文件里面编写如下内容：
FROM centos:7
MAINTAINER krisswen
ENV MYPATH /usr/local
WORKDIR $MYPATH
#安装vim编辑器
RUN yum -y install vim
#安装ifconfig命令查看网络IP
RUN yum -y install net-tools
#安装java8及lib库
RUN yum -y install glibc.i686
RUN mkdir /usr/local/java
#ADD 是相对路径jar,把jdk-8u161-linux-x64.tar.gz添加到容器中,安装包必须要
和Dockerfile文件在同一位置
ADD jdk-8u161-linux-x64.tar.gz /usr/local/java/
#配置java环境变量
ENV JAVA_HOME /usr/local/java/jdk1.8.0_161
ENV JRE_HOME $JAVA_HOME/jre
ENV CLASSPATH
$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib:$CLA
SSPATH
ENV PATH $JAVA_HOME/bin:$PATH
EXPOSE 80
CMD echo $MYPATH
CMD echo "success--------------ok"
CMD /bin/bash
第三步：运行Dockerfile
运行命令的语法格式：docker build -t 镜像名称:标签名称 .(标签名称后面有个空格和点)
[root@shjava101 myfile]# docker build -t newcentos7:1.0 .
[root@shjava101 myfile]# docker images
REPOSITORY TAG
IMAGE ID CREATED SIZE
newcentos7 1.0
12394db42321 8 seconds ago 1.27GB
e2727622a1a7 9 minutes ago 231MB
第四步：运行镜像
[root@shjava101 myfile]# docker run -it 12394db42321 /bin/bash
我们发现进入容器之后，vim工具、ifconfig工具，还有jdk环境都有了。说明我们使用dockerfile制作的镜像没有问题！
2.4.3 虚悬镜像
镜像名称和标签都为
我们也可以自己构建一个虚悬镜像。
[root@shjava101 myfile]# mkdir test
[root@shjava101 myfile]# cd test
[root@shjava101 test]# vim Dockerfile在Dockerfile文件中输入以下内容：
FROM mysql:5.7
CMD echo 'success'保存并退出，build镜像：
[root@shjava101 test]# docker build . 
现在我们需要查看所有的虚悬镜像，然后将所有的虚悬镜像全部删除：
[root@shjava101 test]# docker image ls -f dangling=true # 查看所有的虚悬镜像
REPOSITORY TAG IMAGE ID CREATED SIZE
2c4e05432405 4 minutes ago 448MB
e2727622a1a7 28 minutes ago 231MB
[root@shjava101 test]# docker image prune # 删除所有的虚悬镜像
WARNING! This will remove all dangling images.
Are you sure you want to continue? [y/N] y 2.5 使用Dockerfile进行微服务部署
2.5.1编写一个微服务
第一步：引入依赖
org.springframework.boot
spring-boot-starter-parent
2.5.6
org.springframework.boot
spring-boot-starter-web
2.5.6
org.springframework.boot
spring-boot-maven-plugin
org.apache.maven.plugins
maven-resources-plugin
3.1.0
第二步：编写启动类
@SpringBootApplication
public class App {
public static void main(String[] args) {
SpringApplication.run(App.class,args);
}
}第三步：编写配置文件application.yml
server:
port: 7001第四步：编写controller
@RestController
@RequestMapping("demo1")
public class HelloController {
@RequestMapping("hello")
public String hello(){
return "hello,docker....";
}
}第五步：运行package命令，打成jar包
第六步：将打好的jar包上传至指定目录
[root@shjava101 myfile]# mkdir springboot
[root@shjava101 myfile]# cd springboot/
[root@shjava101 springboot]# ll
total 4
-rw-r--r--. 1 root root 3089 Jan 22 22:43 docker-springboot-
project-1.0-SNAPSHOT.jar2.5.2 编写Dockerfile,打包成镜像
使用vim命令创建Dockerfile文件，并输入以下内容：
# 基础镜像使用java
FROM java:8
# 作者
MAINTAINER wen
# VOLUME 指定临时文件目录为/tmp，在主机/var/lib/docker目录下创建了一个临时
文件并链接到容器的/tmp
VOLUME /tmp
# 将jar包添加到容器中并更名为springboot_docker.jar
ADD docker-springboot-project-1.0-SNAPSHOT.jar
springboot_docker.jar
# touch命令的作用是修改这个文件的访问时间和修改时间为当前时间,不会修改文件的内
容。
RUN bash -c 'touch /springboot_docker.jar'
ENTRYPOINT ["java","-jar","/springboot_docker.jar"]
#暴露7001端口作为微服务
EXPOSE 7001
保存并退出之后，接下来使用Dockerfile文件打成镜像：
[root@shjava101 springboot]# docker build -t springboot_docker:1.1 .2.5.3 运行容器，访问并测试
首先我们查看镜像是否打包成功:
[root@shjava101 springboot]# docker images
REPOSITORY TAG
IMAGE ID CREATED SIZE
springboot_docker 1.1
9f07e1ccb71c 5 minutes ago 643MB接下来我们通过镜像运行一个容器：
[root@shjava101 springboot]# docker run -d -p 7001:7001 springboot_docker:1.1
073e9b29cd18efd45fc2cc9a6846fcea062f966d3408aabd81121fc77f8c6425
[root@shjava101 springboot]# docker ps
CONTAINER ID IMAGE COMMAND
CREATED STATUS PORTS
NAMES
073e9b29cd18 springboot_docker:1.1 "java -jar /springbo…" 3
seconds ago Up 2 seconds 0.0.0.0:7001->7001/tcp, :::7001-
>7001/tcp eager_hodgkin通过浏览器访问测试效果：
九.Docker网络
1.Docker网络的基本概述
接下来我们来认识一下什么是Docker网络：
当我们没有启动docker的时候，我们使用ifconfig命令查看centos7网络情况：
在CentOS7的安装过程中如果有选择相关虚拟化的的服务安装系统后，启动网卡时会发现有一个以网桥连接的私网地址的virbr0网卡(virbr0网卡：它还有一个固定的默认IP地址192.168.122.1)，是做虚拟机网桥的使用的，其作用是为连接其上的虚机网卡提供 NAT访问外网的功能。
当我们启动docker的时候，我们使用ifconfig命令查看centos7网络情况：
[root@shjava101 ~]# systemctl start docker 
这个docker0是什么？也是一个虚拟网桥。通过虚拟网桥可以实现宿主机和docker容器之间的通信。同时容器与容器之间的通信也需要通过虚拟网桥实现。
当我们安装docker之后，默认会帮助我们创建3种网络模式：
[root@shjava101 ~]# docker network ls
NETWORK ID NAME DRIVER SCOPE
402a5ca8f6ac bridge bridge local
b34e9a79539a host host local
0d6fe04a197b none null local下面我们分别对这三种默认的网络模式做一个简单的介绍：
| 网络模式 | 简介 |
| bridge | 为每一个容器分配、设置ip，并将容器连接到一个名为docker0的 虚拟网桥，默认为该模式。 |
| host | 容器将不会虚拟出自己的虚拟网卡，设置自己的ip等。而是使用宿 主机的ip的端口。 使用--network host 参数可以指定 |
| none | 容器有独立的network namespace，但并没有对其进行任何网络 设置，入分配veth pair 和网络桥接 ip等。 使用--network none参 数指定。一般很少使用。 |
| container | 新创建的容器不会创建自己的网卡和设置自己的ip。而是和一个指 定的容器共享ip 端口范围等。 |
2.Docker网络的基本命令
我们可以使用help命令去查看docker的常用命令有哪些？
[root@shjava101 ~]# docker network help
Usage: docker network COMMAND
Manage networks
Commands:
connect Connect a container to a network
create Create a network
disconnect Disconnect a container from a network
inspect Display detailed information on one or more
networks
ls List networks
prune Remove all unused networks
rm Remove one or more networks
Run 'docker network COMMAND --help' for more information on a
command.下面我们对这些基本的网络命令进行介绍：
[root@shjava101 ~]# docker network ls # 查看网络
NETWORK ID NAME DRIVER SCOPE
402a5ca8f6ac bridge bridge local
b34e9a79539a host host local
0d6fe04a197b none null local
[root@shjava101 ~]# docker network inspect bridge # 查看指定网络的详细信息 
[root@shjava101 ~]# docker network create network_abc # 创建一个网络
c9e6626f584e215a77e9d317de11c8e673153985ce5410002cd12710b1ebcced
[root@shjava101 ~]# docker network ls
NETWORK ID NAME DRIVER SCOPE
402a5ca8f6ac bridge bridge local
b34e9a79539a host host local
c9e6626f584e network_abc bridge local
0d6fe04a197b none null local
[root@shjava101 ~]# docker network rm network_abc # 删除指定的网络
network_abc
[root@shjava101 ~]# docker network ls
NETWORK ID NAME DRIVER SCOPE
402a5ca8f6ac bridge bridge local
b34e9a79539a host host local
0d6fe04a197b none null local3. 容器内部网络ip的产生规则
现在我们通过一个案例给大家演示容器内部网络的产生规则，首先我们启动两个ubuntu容器实例
[root@shjava101 ~]# docker run -it --name u1 ubuntu bash
[root@shjava101 ~]# docker run -it --name u2 ubuntu bash
[root@shjava101 ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS
PORTS NAMES
e66faecadd6e ubuntu "bash" 11 seconds ago Up 10
seconds u2
6786c41d50fe ubuntu "bash" About a minute ago Up About
a minute u1现在我们查看两个容器的详细信息：
容器u1:
容器u2：
现在我们关闭容器u2，启动容器u3，观察u3的网络ip：
[root@shjava101 ~]# docker rm -f u2 # 删除容器u2
u2
[root@shjava101 ~]# docker run -it --name u3 ubuntu bash # 启动容器u3 
我们发现容器u3的地址和之前容器u2的地址是一样的！
现在我们得出一个结论：在默认的网络情况下(bridge),容器内部的ip地址是可能会发生变化的，这种情况十分危险，比如我们想通过172.17.0.3这个ip去访问u2.但是现在却访问到了u3。所以我们有必要详细了解docker的网络模式，来对docker网络进行规划。
4.docker网络模式的详细介绍
4.1bridge模式
什么是bridge模式？
Docker 服务默认会创建一个 docker0 网桥（其上有一个 docker0 内部接口），该桥接网络的名称为docker0，它在内核层连通了其他的物理或虚拟网卡，这就将所有容器和本地主机都放到同一个物理网络。Docker 默认指定了 docker0 接口 的 IP 地址和子网掩码，让主机和容器之间可以通过网桥相互通信。
bridge模式的详细解读
1 Docker使用Linux桥接，在宿主机虚拟一个Docker容器网桥(docker0)，Docker启动一个容器时会根据Docker网桥的网段分配给容器一个IP地址，称为Container-IP，同时Docker网桥是每个容器的默认网关。因为在同一宿主机内的容器都接入同一个网桥，这样容器之间就能够通过容器的Container-IP直接通信。
2 docker run 的时候，没有指定network的话默认使用的网桥模式就是bridge，使用的就是docker0。在宿主机ifconfig,就可以看到docker0和自己create的network(后面讲)eth0，eth1，eth2……代表网卡一，网卡二，网卡三……，lo代表127.0.0.1，即localhost，inet addr用来表示网卡的IP地址
3 网桥docker0创建一对对等虚拟设备接口一个叫veth，另一个叫eth0，成对匹配。
3.1 整个宿主机的网桥模式都是docker0，类似一个交换机有一堆接口，每个接口叫veth，在本地主机和容器内分别创建一个虚拟接口，并让他们彼此联通（这样一对接口叫veth pair）；
3.2 每个容器实例内部也有一块网卡，每个接口叫eth0；
3.3 docker0上面的每个veth匹配某个容器实例内部的eth0，两两配对，一一匹配。
通过上述，将宿主机上的所有容器都连接到这个内部网络上，两个容器在同一个网络下,会
从这个网关下各自拿到分配的ip，此时两个容器的网络是互通的。
现在我们通过一个案例来验证默认的bridge网络模式：
我们分别启动两台tomcat容器：
[root@shjava101 ~]# docker run -d -p 8081:8080 --name tomcat81billygoo/tomcat8-jdk8
6d0287d26a16ae2e2e7a79068546e2d0ba02f67fbc4c1bd7502e2e124ccd80fd
[root@shjava101 ~]# docker run -d -p 8082:8080 --name tomcat82 billygoo/tomcat8-jdk8
0b646f197f3911887297f23179eb2005a0b766fd7e248a1301440a6de6547f55我们使用ip addr命令查看centos7网络情况：
这个时候我们发现我们多了两行网络信息(图上红色标注部分)。其实这个就是我们上面讲到的虚拟网桥上的veth。
接下来我们分别进入两个tomcat容器的内部：
首先我们进入tomcat81容器内部：
[root@shjava101 ~]# docker exec -it tomcat81 bash 
接着我们进入容器tomcat82内部：
[root@shjava101 ~]# docker exec -it tomcat82 bash 
4.2 host模式
直接使用宿主机的 IP 地址与外界进行通信，不再需要额外进行NAT 转换。容器将不会获得一个独立的Network Namespace， 而是和宿主机共用一个NetworkNamespace。容器将不会虚拟出自己的网卡而是使用宿主机的IP和端口。
现在我们基于host模式启动一个tomcat容器：
[root@shjava101 ~]# docker run -d -p 8083:8080 --network host -- name tomcat83 billygoo/tomcat8-jdk8
WARNING: Published ports are discarded when using host network
mode
444732c1768290f12eeed07020c801b5c56b67fdd9f00d2570eb0f30ee08b8a3
[root@shjava101 ~]# docker ps
CONTAINER ID IMAGE COMMAND
CREATED STATUS PORTS
NAMES
444732c17682 billygoo/tomcat8-jdk8 "catalina.sh run" 10
seconds ago Up 9 seconds
tomcat83
0b646f197f39 billygoo/tomcat8-jdk8 "catalina.sh run" 25
minutes ago Up 25 minutes 0.0.0.0:8082->8080/tcp, :::8082-
>8080/tcp tomcat82
6d0287d26a16 billygoo/tomcat8-jdk8 "catalina.sh run" 25
minutes ago Up 25 minutes 0.0.0.0:8081->8080/tcp, :::8081-
>8080/tcp tomcat81此时我们发现会报一个警告！通过docker ps发现容器成功启动，但是对应的端口映射并没有出现，这是为什么呢？
原因： docker启动时指定--network=host或-net=host，如果还指定了-p映射端口，那这个时候就会有此警告，并且通过-p设置的参数将不会起到任何作用，端口号会以主机端口号为主。
解决方案：启动容器的时候，不再指定端口映射。
[root@shjava101 ~]# docker run -d --network host --name tomcat83 billygoo/tomcat8-jdk8
f08a48fd5f8b3ab6b2ae345050d372cb58a3234b9d819b149d205043b4dc7220现在我们再查看这个容器的详细信息：
[root@shjava101 ~]# docker inspect tomcat83 | tail -n 20 
现在访问tomcat的ip就是本地宿主机ip+tomcat8080端口访问。
4.3 none模式
在none模式下，并不为Docker容器进行任何网络配置。 也就是说，这个Docker容器没有网卡、IP、路由等信息，只有一个lo需要我们自己为Docker容器添加网卡、配置IP等。
现在我们启动一个tomcat容器：
[root@shjava101 ~]# docker exec -it tomcat84 bash
root@72e422922cb8:/usr/local/tomcat# ip addr
1: lo: mtu 65536 qdisc noqueue state
UNKNOWN group default qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever 我们发现这个容器没有进行任何网络相关的设置。需要我们自己手动进行网络设置。这种网络模式很少用，大家了解即可。
4.4container模式
新建的容器和已经存在的一个容器共享一个网络ip配置而不是和宿主机共享。新创建的容器不会创建自己的网卡，配置自己的IP，而是和一个指定的容器共享IP、端口范围等。同样，两个容器除了网络方面，其他的如文件系统、进程列表等还是隔离的。
为了方便演示，我们启动两个Alpine操作系统的容器。
什么是Alpine操作系统？
Alpine Linux 是一款独立的、非商业的通用 Linux 发行版，专为追求安全性、简单性和资源效率的用户而设计。可能很多人没听说过这个 Linux 发行版本，但是经常用Docker 的朋友可能都用过，因为他小，简单，安全而著称，所以作为基础镜像是非常好的一个选择，可谓是麻雀虽小但五脏俱全，镜像非常小巧，不到 6M的大小，所以特别适合容器打包。
现在我们分别启动2个终端。
在终端1：
[root@shjava101 ~]# docker run -it --name alpine1 alpine
/bin/sh
Unable to find image 'alpine:latest' locally
latest: Pulling from library/alpine
59bf1c3509f3: Pull complete
Digest:
sha256:21a3deaa0d32a8057914f36584b5288d2e5ecc984380bc0118285c70fa
8c9300
Status: Downloaded newer image for alpine:latest
/ #在终端2：
[root@shjava101 ~]# docker run -it --network container:alpine1 -- name alpine2 alpine /bin/sh
/ #我们在终端1里面查看网络情况
我们再在终端2里面查看网络情况：
我们发现容器2的网络地址和容器1里面的是一样的。说明容器2共享了容器1的网络信息。
5.自定义网络模式
上面讲过，默认使用bridge网络模式，容器内部的ip在某些情况下会发生变化，如果此时通过容器的ip地址进行通信可能会遇到问题，如果我们想和某个容器之间建立通信的话，应该怎么做呢？可以使用容器名称建立通信(类似于微服务中通过服务名称实现服务之间的远程调用)。
接下来我们通过一个案例演示自定义网络模式。
我们还是分别启动两台tomcat容器
[root@shjava101 ~]# docker run -d -p 8081:8080 --name tomcat81 billygoo/tomcat8-jdk8
6d0287d26a16ae2e2e7a79068546e2d0ba02f67fbc4c1bd7502e2e124ccd80fd
[root@shjava101 ~]# docker run -d -p 8082:8080 --name tomcat82 billygoo/tomcat8-jdk8
0b646f197f3911887297f23179eb2005a0b766fd7e248a1301440a6de6547f55上述成功启动并用docker exec进入各自容器实例内部
[root@shjava101 ~]# docker exec -it tomcat81 bash # 在终端1进入tomcat81容器
root@6d0287d26a16:/usr/local/tomcat# ip addr
1: lo: mtu 65536 qdisc noqueue state
UNKNOWN group default qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
13: eth0@if14: mtu 1500 qdisc
noqueue state UP group default
link/ether 02:42:ac:11:00:04 brd ff:ff:ff:ff:ff:ff link-
netnsid 0
inet 172.17.0.4/16 brd 172.17.255.255 scope global eth0
valid_lft forever preferred_lft forever
[root@shjava101 ~]# docker exec -it tomcat82 bash # 在终端2进入tomcat82容器
root@0b646f197f39:/usr/local/tomcat# ip addr
1: lo: mtu 65536 qdisc noqueue state
UNKNOWN group default qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
15: eth0@if16: mtu 1500 qdisc
noqueue state UP group default
link/ether 02:42:ac:11:00:05 brd ff:ff:ff:ff:ff:ff link-
netnsid 0
inet 172.17.0.5/16 brd 172.17.255.255 scope global eth0
valid_lft forever preferred_lft forever 下面我们在容器1(tomcat81)里面ping容器2(tomcat82)
root@6d0287d26a16:/usr/local/tomcat# ping 172.17.0.5
PING 172.17.0.5 (172.17.0.5) 56(84) bytes of data.
64 bytes from 172.17.0.5: icmp_seq=1 ttl=64 time=0.335 ms
64 bytes from 172.17.0.5: icmp_seq=2 ttl=64 time=0.048 ms
64 bytes from 172.17.0.5: icmp_seq=3 ttl=64 time=0.050 ms
--- 172.17.0.5 ping statistics ---
8 packets transmitted, 8 received, 0% packet loss, time 6999ms
rtt min/avg/max/mdev = 0.045/0.083/0.335/0.095 ms我们发现可以ping通，反过来我们在容器1(tomcat82)里面ping容器2(tomcat81)
root@0b646f197f39:/usr/local/tomcat# ping 172.17.0.4
PING 172.17.0.4 (172.17.0.4) 56(84) bytes of data.
64 bytes from 172.17.0.4: icmp_seq=1 ttl=64 time=0.092 ms
64 bytes from 172.17.0.4: icmp_seq=2 ttl=64 time=0.047 ms
64 bytes from 172.17.0.4: icmp_seq=3 ttl=64 time=0.047 ms
--- 172.17.0.4 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2000ms
rtt min/avg/max/mdev = 0.047/0.062/0.092/0.021 ms我们发现也可以ping通。
现在我们通过容器名称去ping呢？
我们在容器1(tomcat81)里面通过服务名称去ping容器2(tomcat82)
root@6d0287d26a16:/usr/local/tomcat# ping tomcat82
ping: tomcat82: Name or service not known我们在容器1(tomcat82)里面通过服务名称去ping容器2(tomcat81)
root@0b646f197f39:/usr/local/tomcat# ping tomcat81
ping: tomcat81: Name or service not known 我们发现使用服务名称不能ping通对方的容器。此时我们可以使用自定义网络来解决这个问题。
我们先删除tomcat81 tomcat82两台容器。
[root@shjava101 ~]# docker rm -f tomcat81
tomcat81
[root@shjava101 ~]# docker rm -f tomcat82
tomcat82我们先自定义网络
[root@shjava101 ~]# docker network create wen_network
4908cb50bd5aaf3e576979d3eb9d23ebdff8624b747bdee40ab4f673ce347c95接下来我们按照自定义网络模式启动容器
[root@shjava101 ~]# docker run -d -p 8081:8080 --network wen_network --name tomcat81 billygoo/tomcat8-jdk8
d8cc378a1760987df457d85c58ddeb05faab214a67e793f93db251f57b2b2389
[root@shjava101 ~]# docker run -d -p 8082:8080 --network wen_network --name tomcat82 billygoo/tomcat8-jdk8
f6ed10697e5ba7629853142ed8520c4f132441b31f937cc3b6006a7c40c50722最后我们按照服务名称来ping对方的容器。
[root@shjava101 ~]# docker exec -it tomcat81 bash
root@d8cc378a1760:/usr/local/tomcat# ping tomcat82
PING tomcat82 (172.19.0.3) 56(84) bytes of data.
64 bytes from tomcat82.wen_network (172.19.0.3): icmp_seq=1
ttl=64 time=0.075 ms
64 bytes from tomcat82.wen_network (172.19.0.3): icmp_seq=2
ttl=64 time=0.047 ms
64 bytes from tomcat82.wen_network (172.19.0.3): icmp_seq=3
ttl=64 time=0.047 ms
--- tomcat82 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 1999ms
rtt min/avg/max/mdev = 0.047/0.056/0.075/0.014 ms
[root@shjava101 ~]# docker exec -it tomcat82 bash
root@f6ed10697e5b:/usr/local/tomcat# ping tomcat81
PING tomcat81 (172.19.0.2) 56(84) bytes of data.
64 bytes from tomcat81.wen_network (172.19.0.2): icmp_seq=1
ttl=64 time=0.041 ms
64 bytes from tomcat81.wen_network (172.19.0.2): icmp_seq=2
ttl=64 time=0.152 ms
64 bytes from tomcat81.wen_network (172.19.0.2): icmp_seq=3
ttl=64 time=0.047 ms
--- tomcat81 ping statistics ---
4 packets transmitted, 4 received, 0% packet loss, time 3000ms
rtt min/avg/max/mdev = 0.041/0.071/0.152/0.047 ms 现在我们基于自定义网络模式成功通过容器名称ping通了对方。
小结：自定义网络本身就维护好了主机名和ip的对应关系（ip和域名都能通）
十.Docker-compose容器编排
1.Docker Compose的基本概述
Docker-Compose是Docker官方的开源项目， 负责实现对Docker容器集群的快速编排。Compose 是 Docker 公司推出的一个工具软件，可以管理多个 Docker 容器组成一个应用。你需要定义一个 YAML 格式的配置文件docker-compose.yml，写好多个容器之间的调用关系。然后，只要一个命令，就能同时启动/关闭这些容器。我们可以通过一幅图来理解什么是Docker-Compose。
docker建议我们每一个容器中只运行一个服务,因为docker容器本身占用资源极少,所以最
好是将每个服务单独的分割开来但是这样我们又面临了一个问题？
如果我需要同时部署好多个服务,难道要每个服务单独写Dockerfile然后在构建镜像,构建容器,这样非常复杂,所以docker官方给我们提供了docker-compose多服务部署的工具例如要实现一个Web微服务项目，除了Web服务容器本身，往往还需要再加上后端的数据库mysql服务容器，redis服务器，注册中心eureka，甚至还包括负载均衡容器等等。
Compose允许用户通过一个单独的docker-compose.yml模板文件（YAML 格式）来定义
一组相关联的应用容器为一个项目（project）。
可以很容易地用一个配置文件定义一个多容器的应用，然后使用一条指令安装这个应用的所
有依赖，完成构建。Docker-Compose 解决了容器与容器之间如何管理编排的问题
下面我们就开始安装docker compose
[root@shjava101 ~]# curl -L
https://get.daocloud.io/docker/compose/releases/download/1.25.1/d
ocker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-
compose
[root@shjava101 ~]# chmod +x /usr/local/bin/docker-compose # 给这
个docker-compose文件设置权限
[root@shjava101 ~]# docker-compose --version
docker-compose version 1.25.1, build a82fef072. Docker Compose的基本使用
2.1Docker Compose的基本概念
一个文件：docker-compose.yml 描述多个容器之间的运行规则。
两个要素：
服务(service) 一个个应用容器实例，比如订单微服务、库存微服务、mysql容器、nginx容器或者redis容器。
工程(project) 由一组关联的应用容器组成的一个完整业务单元，在 docker-compose.yml 文件中定义。
2.2Docker Compose使用的三个步骤
编写Dockerfile定义各个微服务应用并构建出对应的镜像文件
使用 docker-compose.yml 定义一个完整业务单元，安排好整体应用中的各个容器服务。
最后，执行docker-compose up命令 来启动并运行整个应用程序，完成一键部署上线
2.3 Docker Compose的常用基本命令
Compose常用命令
docker-compose -h # 查看帮助
docker-compose up # 启动所有docker-
compose服务
docker-compose up -d # 启动所有docker-
compose服务并后台运行
docker-compose down # 停止并删除容器、网络、
卷、镜像。
docker-compose exec yml里面的服务id # 进入容器实例内部
docker-compose exec docker-compose.yml文件中写的服务id /bin/bash
docker-compose ps # 展示当前docker-compose编排
过的运行的所有容器
docker-compose top # 展示当前docker-compose编排
过的容器进程
docker-compose logs yml里面的服务id # 查看容器输出日志
docker-compose config # 检查配置
docker-compose config -q # 检查配置，有问题才有输出
docker-compose restart # 重启服务
docker-compose start # 启动服务
docker-compose stop # 停止服务3. 使用Docker Compose进行服务编排
3.1准备微服务
引入POM依赖
org.springframework.boot
spring-boot-starter-parent
2.5.6
org.springframework.boot
spring-boot-starter-web
2.5.6
com.alibaba
druid-spring-boot-starter
1.1.10
org.mybatis.spring.boot
mybatis-spring-boot-starter
1.3.0
mysql
mysql-connector-java
5.1.6
org.springframework.boot
spring-boot-maven-plugin
org.apache.maven.plugins
maven-resources-plugin
3.1.0
编写启动类
@SpringBootApplication
public class App {
public static void main(String[] args) {
SpringApplication.run(App.class,args);
}
}编写配置文件
server.port=7001
# 配置数据源类型
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
# 配置数据库用户名
spring.datasource.username=root
# 配置数据库密码
spring.datasource.password=123456
# 配置连接数据库的url
#spring.datasource.url=jdbc:mysql://192.168.10.145:3306/docker?
useUnicode=true&characterEncoding=utf-8&useSSL=false
# mysql替代192.168.10.145 通过容器名称进行访问
spring.datasource.url=jdbc:mysql://mysql:3306/docker?
useUnicode=true&characterEncoding=utf-8&useSSL=false
# 配置驱动类
spring.datasource.driver-class-name=com.mysql.jdbc.Driver编写dao
@Mapper
public interface AccountDao {
@Select("select * from account where id = #{id}")
public Account findById(Integer id);
}编写service
public interface AccountService {
public Account findAccountById(Integer id);
}
@Service
@SuppressWarnings("all")
public class AccountServiceImpl implements AccountService {
@Autowired
AccountDao accountDao;
@Override
public Account findAccountById(Integer id) {
return accountDao.findById(id);
}
}编写controller
@RestController
@RequestMapping("account")
public class AccountController {
@Autowired
AccountService accountService;
@RequestMapping("findById")
public Account findById(@RequestParam("id") Integer id){
return accountService.findAccountById(id);
}
} 打包项目成jar包，并上传到指定目录
使用mvn package 命令将微服务打成jar包并上传至linux服务器/mydocker目录下面。
3.2 编写docker-compose.yml文件
在/mydocker目录下面编写docker-compose.yml
version: "3"
services:
microService:
image: account_docker:1.1
container_name: account
ports:
- "7001:7001"
volumes:
- /app/microService:/data
networks:
- wen_net
depends_on:
- mysql
mysql:
image: mysql:5.7
environment:
MYSQL_ROOT_PASSWORD: '123456'
MYSQL_ALLOW_EMPTY_PASSWORD: 'no'
MYSQL_DATABASE: 'docker'
MYSQL_USER: 'wen'
MYSQL_PASSWORD: 'wen123'
ports:
- "3306:3306"
volumes:
- /app/mysql/db:/var/lib/mysql
- /app/mysql/conf/my.cnf:/etc/my.cnf
- /app/mysql/init:/docker-entrypoint-initdb.d
networks:
- wen_net
command: --default-authentication-
plugin=mysql_native_password #解决外部无法访问
networks:
wen_net:3.3 编写Dockerfile
# 基础镜像使用java
FROM java:8
# 作者
MAINTAINER krisswen
# VOLUME 指定临时文件目录为/tmp，在主机/var/lib/docker目录下创建了一个临时
文件并链接到容器的/tmp
VOLUME /tmp
# 将jar包添加到容器中并更名为docker-springboot-project-1.0-
SNAPSHOT.jar
ADD docker-springboot-project-1.0-SNAPSHOT.jar
account_docker.jar
# 运行jar包
RUN bash -c 'touch /account_docker.jar'
ENTRYPOINT ["java","-jar","/account_docker.jar"]
#暴露7001端口作为微服务
EXPOSE 70013.4 构建镜像
[root@shjava101 mydocker]# docker build -t account_docker:1.1 3.5 启动所有docker-compose服务
[root@shjava101 mydocker]# docker-compose up -d我们查看运行的容器：
查看dcoker网络：
在数据表里面添加对应的数据，使用浏览器进行测试：
十一.Docker轻量级可视化工具
当我们的镜像越来越多，容器也越来越多，我们需要统计容器启动的数目，监控容器的运行情况。这个时候需要一款可视化工具来帮助我们进行统计和监控。我们可以使用Portainer这款工具来协助我们。
什么是Portainer？Portainer 是一款轻量级的应用，它提供了图形化界面，用于方便地管理Docker环境，包括单机环境和集群环境。
1.安装可视化工具Portainer
第一步：使用docker命令安装
[root@shjava101 ~]# docker run -d -p 8000:8000 -p 9000:9000 --
name portainer --restart=always -v
/var/run/docker.sock:/var/run/docker.sock -v
portainer_data:/data portainer/portainer
Unable to find image 'portainer/portainer:latest' locally
latest: Pulling from portainer/portainer
94cfa856b2b1: Pull complete
49d59ee0881a: Pull complete
a2300fd28637: Pull complete
Digest:
sha256:fb45b43738646048a0a0cc74fcee2865b69efde857e710126084ee5de9
be0f3f
Status: Downloaded newer image for portainer/portainer:latest
cd3cdcc6e8b5e33524be288607efc9a50ac456680504fb8f32d0c4e25d5d690f安装成功之后，我们可以查看portainer运行的容器
第二步：访问首页，设置admin用户的密码
使用ip地址+9000来访问：
第三步：设置密码后首次登录
第四步： 选择local选项卡后本地docker详细信息展示
点击进去：
十二.Docker容器监控之CAdvisor+InfluxDB+Granfana
我们可以通过docker stats命令可以很方便的看到当前宿主机上所有容器的CPU,内存以及网络流量等数据，一般小公司够用了。但是，docker stats统计结果只能是当前宿主机的全部容器，数据资料是实时的，没有地方存储、没有健康指标过线预警等功能。
1. CAdvisor InfluxDB Granfana是什么
CAdvisor监控收集+InfluxDB存储数据+Granfana展示图表
CAdvisor
CAdvisor是一个容器资源监控工具，包含了容器的内存，CPU，网络IO，磁盘IO等监控。同时提供了一个WEB页面用于查看容器的实时运行状态。CAdvisor默认存储2分钟的数据，而且只是针对单物理机，不过CAdvisor提供了很多数据继承接口，支持
InfluxDB,Redis,Kafka,ElasticSearch等集成，可以加上对应的配置将监控数据发往这些数据库存储起来。
CAdvisor功能主要有2点：
展示Host和容器两个层次的监控数据
展示历史变化数据
InfluxDB
InfluxDB是使用go语言编写的一个开源分布式时序，事件和指标数据库，无需外部依赖。CAdvisor默认只在本机保存最近2分钟的数据，为了持久化存储数据和统一收集展示监控数
据，需要将数据存储到InfluxDB中。InfluxDB是一个时序数据库，专门用于存储时序相关的数据。很适合存储CAdvisor数据。而且CAdvisor本身已经提供了继承InfluxDB的方法。
InfluxDB的主要功能：
基于时间序列，支持与时间相关的函数
可度量性，可以实时对大量数据进行计算
它支持任意的事件数据
Granfana
Granfana是一个开源的数据监控分析可视化平台，支持多种数据源配置(支持包括InfluxDB,Mysql,Elasticsearch等)和丰富的插件及模板功能。支持图标权限控制和报警。
Granfana的主要特性：
丰富灵活的图形化选项
可以混合多种风格
支持白天和夜间模式
多个数据源
2. 使用Docker Compose搭建CIG监控平台
第一步：新建目录
[root@shjava101 mydocker]# mkdir cig
[root@shjava101 mydocker]# pwd
[root@shjava101 mydocker]# cd cig
[root@shjava101 cig]# pwd
/mydocker/cig第二步：新建docker-compose.yml
version: '3.1'
volumes:
grafana_data: {}
services:
influxdb:
image: tutum/influxdb:0.9
restart: always
environment:
- PRE_CREATE_DB=cadvisor
ports:
- "8083:8083"
- "8086:8086"
volumes:
- ./data/influxdb:/data
cadvisor:
image: google/cadvisor
links:
- influxdb:influxsrv
command: -storage_driver=influxdb -storage_driver_db=cadvisor -
storage_driver_host=influxsrv:8086
restart: always
ports:
- "8080:8080"
volumes:
- /:/rootfs:ro
- /var/run:/var/run:rw
- /sys:/sys:ro
- /var/lib/docker/:/var/lib/docker:ro
grafana:
user: "104"
image: grafana/grafana
user: "104"
restart: always
links:
- influxdb:influxsrv
ports:
- "3000:3000"
volumes:
- grafana_data:/var/lib/grafana
environment:
- HTTP_USER=admin
- HTTP_PASS=admin
- INFLUXDB_HOST=influxsrv
- INFLUXDB_PORT=8086
- INFLUXDB_NAME=cadvisor
- INFLUXDB_USER=root
- INFLUXDB_PASS=root第三步：启动docker-compose文件
[root@shjava101 cig]# docker-compose config -q # 检查docker-compose.yml文件是否有语法错误
[root@shjava101 cig]# docker-compose up如果启动成功，效果如下：
我们查看三个启动的容器实例：
3. 访问服务
3.1访问CAdvisor收集服务
使用ip地址+8080端口进行访问(一定要注意tomcat 8080端口没有占用)。第一次访问比较慢，耐心等待。
3.2 访问InfluxDB存储服务
使用ip地址+8083端口进行访问
3.3 访问Granfana展现服务
使用ip地址+3000端口进行访问
默认用户名和密码都是admin。登录以后进入到主页：
我们要通过Granfana展现数据，那么数据源在哪里呢？我们需要先配置数据源。
选中数据源DataSource,然后我们添加数据源：
我们选择InfluxDB数据源
点击select之后，我们进入具体的配置细节：
接下来配置数据库名称以及用户名和密码
点击Save & test测试。
接下来我们配置面板
我们选择数据展示格式，是折线图，还是柱状图展示等：
我们选择最经典的展示规则：
最后我们保存设置
保存之后，效果如下：
现在我们的面板上并没有展示数据，接下来我们对其进行继续配置：
我们对面板进行编辑：
往下拉，继续配置：
容器名称可以在这里看：
[root@shjava101 cig]# docker stats 
最后效果如下：
最后保存日志监控信息
最后监控效果如下：
到这里cAdvisor+InfluxDB+Grafana容器监控系统就部署完成了
十三.Swarm mode
一般情况下，我们都在一台机器下部署容器，但实际情况下，应用如果只在一台机器上无法满足我们的需求，包含的容器比较多。因此在生产环境下部署我们的应用就会涉及到非常多的容器，这样就会给我们带来一系列的问题：
怎么去管理这么多的容器？
怎么能方便的横向扩展？
如果容器down了，怎么能自动恢复？
如何去更新容器而不影响业务？
如何去监控追踪这些容器?
怎么去调度容器的创建？
保护隐私数据？
这样我们就需要容器编排技术，Swarm Mode应运而生。
Swarm 并不是唯一一个可以做容器编排的工具，只不过Swarm是内置于docker的一个工具。因此我们使用Swarm时不需要安装任何东西，Swarm已经内置到我们系统里面了，只不过我们没有运行在Swarm 模式下，我们一般运行在单机模式下。因此swarm就是初学者接触容器编排的第一个工具。在使用Swarm之前，我们先了解Swarm的基本概念。
1.Swarm的基本概念
1.1节点
运行Docker的主机可以主动初始化一个Swarm集群或者加入一个已存在的Swarm集群，这样这个运行Docker的主机就成为一个Swarm集群的节点 。
节点分为管理节点和工作节点。
管理节点用于Swarm集群的管理，docker swarm命令基本只能在管理节点执行（节点退出集群命令docker swarm leave可以在工作节点执行）。一个Swarm集群可以有多个管理节点，但只有一个管理节点可以成为leader，leader通过raft协议实现。工作节点是任务执行节点，管理节点将服务下发至工作节点执行。管理节点默认也作为工作节点。你也可以通过配置让服务只运行在管理节点。
来自Docker官网的这张图片形象的展示了集群中管理节点与工作节点的关系。
1.2 服务和任务
任务（Task）是Swarm中的最小的调度单位，目前来说就是一个单一的容器。
服务（Services）是指一组任务的集合，服务定义了任务的属性。服务有两种模式：
replicated services按照一定规则在各个工作节点上运行指定个数的任务。
global services每个工作节点上运行一个任务。
两种模式通过docker service create的--mode参数指定。
2. 创建Swarm集群
创建一个包含一个管理节点和两个工作节点的最小Swarm集群。
2.1创建管理节点
执行 docker swarm init 命令的节点自动成为管理节点。在已经安装好Docker的主机(192.168.10.145)上执行如下命令：
[root@shjava101 ~]# docker swarm init --advertise-addr
192.168.10.145
Swarm initialized: current node (n7qns7hjyy7oi9ituff3n7xsi) is
now a manager.
To add a worker to this swarm, run the following command:
docker swarm join --token SWMTKN-1-
3cgjy8qej9x6v52dk1o33jv5bb0630kt4eovjvnfoky3cihohi-
ccczg5p1scxzc96ch92g1kkrv 192.168.10.145:2377
To add a manager to this swarm, run 'docker swarm join-token
manager' and follow the instructions.2.2 增加工作节点
上一步初始化了一个Swarm集群，拥有了一个管理节点，在其他的Docker主机中分别执行如下命令，创建工作节点并加入到集群中。
在192.168.10.146机器和192.168.10.147机器上分别执行上面红框的命令：
[root@shjava103 ~]# docker swarm join --token SWMTKN-1-
3cgjy8qej9x6v52dk1o33jv5bb0630kt4eovjvnfoky3cihohi-
ccczg5p1scxzc96ch92g1kkrv 192.168.10.145:2377如果成功，会有以下提示：
2.3 查看集群
经过上边的两步，已经拥有了一个最小的Swarm集群，包含一个管理节点和两个工作节点。
在管理节点使用 docker node ls 查看集群。
[root@shjava101 ~]# docker node ls
3. 部署服务
我们使用 docker service 命令来管理Swarm集群中的服务，该命令只能在管理节点运行
3.1新建服务
现在我们在上一节创建的Swarm集群中运行一个名为nginx服务。
[root@shjava101 ~]# docker service create --replicas 3 -p 80:80 -
-name nginx nginx:1.13.7-alpine
rmxr9hhqw9n09eftpa98xnubj
overall progress: 3 out of 3 tasks
1/3: running
[==================================================>]
2/3: running
[==================================================>]
3/3: running
[==================================================>]
verify: Service converged现在我们使用浏览器，输入任意节点IP ，即可看到nginx默认页面
3.2 查看服务
使用 docker service ls 来查看当前Swarm集群运行的服务。
使用 docker service ps 来查看某个服务的详情。
[root@shjava101 ~]# docker service ps nginx 
使用 docker service logs 来查看某个服务的日志。
3.3 服务伸缩
我们可以使用 docker service scale 对一个服务运行的容器数量进行伸缩。当业务处于高峰期时，我们需要扩展服务运行的容器数量。
[root@shjava101 ~]# docker service scale nginx=5
nginx scaled to 5
overall progress: 5 out of 5 tasks
1/5: running
[==================================================>]
2/5: running
[==================================================>]
3/5: running
[==================================================>]
4/5: running
[==================================================>]
5/5: running
[==================================================>]
[root@shjava101 ~]# docker service ps nginx
ID NAME IMAGE NODE
DESIRED STATE CURRENT STATE ERROR PORTS
t71st5vejyrf nginx.1 nginx:1.13.7-alpine shjava103
Running Running 10 minutes ago
ev9d3ej89x3x nginx.2 nginx:1.13.7-alpine shjava102
Running Running 11 minutes ago
dk5a6pnf3gda nginx.3 nginx:1.13.7-alpine shjava101
Running Running 11 minutes ago
nozmp1gnb9yz nginx.4 nginx:1.13.7-alpine shjava103
Running Running 22 seconds ago
ivw72iml1ui3 nginx.5 nginx:1.13.7-alpine shjava101
Running Running 22 seconds ago 当业务平稳时，我们需要减少服务运行的容器数量。
[root@shjava101 ~]# docker service scale nginx=2
nginx scaled to 2
overall progress: 2 out of 2 tasks
1/2: running
[==================================================>]
2/2: running
[==================================================>]
verify: Service converged
[root@shjava101 ~]# docker service ps nginx
ID NAME IMAGE NODE
DESIRED STATE CURRENT STATE ERROR PORTS
t71st5vejyrf nginx.1 nginx:1.13.7-alpine shjava103
Running Running 12 minutes ago
ev9d3ej89x3x nginx.2 nginx:1.13.7-alpine shjava102
Running Running 13 minutes ago 3.4 删除服务
使用 docker service rm 来从Swarm集群移除某个服务。
[root@shjava101 ~]# docker service rm nginx
nginx4. 使用compose文件
正如之前使用docker-compose.yml来一次配置、启动多个容器，在Swarm集群中也可以使用compose文件（docker-compose.yml）来配置、启动多个服务。上一节中，我们使用docker service create一次只能部署一个服务，使用docker-compose.yml我们可以一次启动多个关联的服务。我们以在Swarm集群中部署visualizer说明。visualizer服务提供一个可视化页面，我们可以从浏览器中很直观的查看集群中各个服务的运行节点。
4.1编写docker-compose.yml
在根目录创建swarm目录，进入swarm目录，编写docker-compose.yml文件
[root@shjava101 /]# mkdir /swarm
[root@shjava101 /]# cd swarm
[root@shjava101 swarm]# vim docker-compose.yml
version: "3"
services:
wordpress:
image: wordpress
ports:
- 80:80
networks:
- overlay
environment:
WORDPRESS_DB_HOST: db:3306
WORDPRESS_DB_USER: wordpress
WORDPRESS_DB_PASSWORD: wordpress
deploy:
mode: replicated
replicas: 3
db:
image: mysql
networks:
- overlay
volumes:
- db-data:/var/lib/mysql
environment:
MYSQL_ROOT_PASSWORD: somewordpress
MYSQL_DATABASE: wordpress
MYSQL_USER: wordpress
MYSQL_PASSWORD: wordpress
deploy:
placement:
constraints: [node.role == manager]
visualizer:
image: dockersamples/visualizer:stable
ports:
- "8080:8080"
stop_grace_period: 1m30s
volumes:
- "/var/run/docker.sock:/var/run/docker.sock"
deploy:
placement:
constraints: [node.role == manager]
volumes:
db-data:
networks:
overlay:在Swarm集群中使用 docker-compose.yml 我们用 docker stack 命令，下面我们对该命令进行详细讲解
4.2部署服务
部署服务使用 docker stack deploy ，其中 -c 参数指定compose文件名。
[root@shjava101 swarm]# docker stack deploy -c docker-compose.yml wordpress
Updating service wordpress_visualizer (id:
eazpx9nakchvnosn5tyir35zt)
Updating service wordpress_wordpress (id:
9bvtwvveyzy6oiaxwfskch99d)
Updating service wordpress_db (id: f4rbk28gc9jtdue9ainbtudj7)
[root@shjava101 swarm]# docker stack ls #查看服务
NAME SERVICES ORCHESTRATOR
wordpress 3 Swarm现在我们打开浏览器输入任一节点IP:8080 即可看到各节点运行状态。如下图所示：
总结
同样的代码框里面全是命令行，所以是灰色的。