一、基础篇
1、Docker简介
1.1、是什么
1.1.1、问题:为什么会有docker出现
假定您在开发一个尚硅谷的谷粒商城,您使用的是一台笔记本电脑而且您的开发环境具有特定的配置。其他开发人员身处的环境配置也各有不同。您正在开发的应用依赖于您当前的配置且还要依赖于某些配置文件。此外,您的企业还拥有标准化的测试和生产环境,且具有自身的配置和一系列支持文件。您希望尽可能多在本地模拟这些环境而不产生重新创建服务器环境的开销。请问?
您要如何确保应用能够在这些环境中运行和通过质量检测?并且在部署过程中不出现令人头疼的版本、配置问题,也无需重新编写代码和进行故障修复?
答案就是使用容器。Docker之所以发展如此迅速,也是因为它对此给出了一个标准化的解决方案—–系统平滑移植,容器虚拟化技术。
环境配置相当麻烦,换一台机器,就要重来一次,费力费时。很多人想到,能不能从根本上解决问题,软件可以带环境安装?也就是说,安装的时候,把原始环境一模一样地复制过来。开发人员利用 Docker 可以消除协作编码时“在我的机器上可正常工作”的问题。
之前在服务器配置一个应用的运行环境,要安装各种软件,就拿尚硅谷电商项目的环境来说,Java/RabbitMQ/MySQL/JDBC驱动包等。安装和配置这些东西有多麻烦就不说了,它还不能跨平台。假如我们是在 Windows 上安装的这些环境,到了 Linux 又得重新装。况且就算不跨操作系统,换另一台同样操作系统的服务器,要移植应用也是非常麻烦的。
传统上认为,软件编码开发/测试结束后,所产出的成果即是程序或是能够编译执行的二进制字节码等(java为例)。而为了让这些程序可以顺利执行,开发团队也得准备完整的部署文件,让维运团队得以部署应用程式,开发需要清楚的告诉运维部署团队,用的全部配置文件+所有软件环境。不过,即便如此,仍然常常发生部署失败的状况。Docker的出现使得Docker得以打破过去「程序即应用」的观念。透过镜像(images)将作业系统核心除外,运作应用程式所需要的系统环境,由下而上打包,达到应用程式跨平台间的无缝接轨运作。
1.1.2、docker理念
Docker是基于Go语言实现的云开源项目。
Docker的主要目标是“Build,Ship and Run Any App,Anywhere”,也就是通过对应用组件的封装、分发、部署、运行等生命周期的管理,使用户的APP(可以是一个WEB应用或数据库应用等等)及其运行环境能够做到“一次镜像,处处运行”。
Linux容器技术的出现就解决了这样一个问题,而 Docker 就是在它的基础上发展过来的。将应用打成镜像,通过镜像成为运行在Docker容器上面的实例,而 Docker容器在任何操作系统上都是一致的,这就实现了跨平台、跨服务器。只需要一次配置好环境,换到别的机子上就可以一键部署好,大大简化了操作。
1.1.3、一句话
解决了运行环境和配置问题的软件容器,方便做持续集成并有助于整体发布的容器虚拟化技术。
1.2、容器与虚拟机比较
1.2.1、容器发展简史
1.2.2、传统虚拟机技术
虚拟机(virtual machine)就是带环境安装的一种解决方案。
它可以在一种操作系统里面运行另一种操作系统,比如在Windows10系统里面运行Linux系统CentOS7。应用程序对此毫无感知,因为虚拟机看上去跟真实系统一模一样,而对于底层系统来说,虚拟机就是一个普通文件,不需要了就删掉,对其他部分毫无影响。这类虚拟机完美的运行了另一套系统,能够使应用程序,操作系统和硬件三者之间的逻辑不变。
1.2.3、容器虚拟化技术
由于前面虚拟机存在某些缺点,Linux发展出了另一种虚拟化技术:
Linux容器(Linux Containers,缩写为 LXC)
Linux容器是与系统其他部分隔离开的一系列进程,从另一个镜像运行,并由该镜像提供支持进程所需的全部文件。容器提供的镜像包含了应用的所有依赖项,因而在从开发到测试再到生产的整个过程中,它都具有可移植性和一致性。
Linux 容器不是模拟一个完整的操作系统而是对进程进行隔离。有了容器,就可以将软件运行所需的所有资源打包到一个隔离的容器中。容器与虚拟机不同,不需要捆绑一整套操作系统,只需要软件工作所需的库资源和设置。系统因此而变得高效轻量并保证部署在任何环境中的软件都能始终如一地运行。
1.2.5、对比
比较了 Docker 和传统虚拟化方式的不同之处:
传统虚拟机技术是虚拟出一套硬件后,在其上运行一个完整操作系统,在该系统上再运行所需应用进程;
容器内的应用进程直接运行于宿主的内核,容器内没有自己的内核且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便。
每个容器之间互相隔离,每个容器有自己的文件系统 ,容器之间进程不会相互影响,能区分计算资源。
1.3、能干嘛
1.3.1、技术职级变化
coder->programmer->software engineer
1.3.2、开发/运维(DevOps)新一代开发工程师
一次构建、随处运行:
更快速的应用交付和部署
传统的应用开发完成后,需要提供一堆安装程序和配置说明文档,安装部署后需根据配置文档进行繁杂的配置才能正常运行。Docker化之后只需要交付少量容器镜像文件,在正式生产环境加载镜像并运行即可,应用安装配置在镜像里已经内置好,大大节省部署配置和测试验证时间。
更便捷的升级和扩缩容
随着微服务架构和Docker的发展,大量的应用会通过微服务方式架构,应用的开发构建将变成搭乐高积木一样,每个Docker容器将变成一块“积木”,应用的升级将变得非常容易。当现有的容器不足以支撑业务处理时,可通过镜像运行新的容器进行快速扩容,使应用系统的扩容从原先的天级变成分钟级甚至秒级。
更简单的系统运维
应用容器化运行后,生产环境运行的应用可与开发、测试环境的应用高度一致,容器会将应用程序相关的环境和状态完全封装起来,不会因为底层基础架构和操作系统的不一致性给应用带来影响,产生新的BUG。当出现程序异常时,也可以通过测试环境的相同容器进行快速定位和修复。
更高效的计算资源利用
Docker是内核级虚拟化,其不像传统的虚拟化技术一样需要额外的Hypervisor支持,所以在一台物理机上可以运行很多个容器实例,可大大提升物理服务器的CPU和内存的利用率。
Docker应用场景:
1.3.3、哪些企业在使用
新浪:
美团:
蘑菇街:
1.4、去哪下
官网:docker官网:http://www.docker.com
仓库:Docker Hub官网: https://hub.docker.com/
2、Docker安装
2.1、前提说明
前提条件
目前,CentOS 仅发行版本中的内核支持 Docker。Docker 运行在CentOS 7 (64-bit)上,
要求系统为64位、Linux系统内核版本为 3.8以上,这里选用Centos7.x
查看自己的内核
uname命令用于打印当前系统相关信息(内核版本号、硬件架构、主机名称和操作系统类型等)。
2.2、Docker的基本组成
Docker平台架构图解(入门版):
Docker工作原理:
Docker是一个Client-Server结构的系统,Docker守护进程运行在主机上, 然后通过Socket连接从客户端访问,守护进程从客户端接受命令并管理运行在主机上的容器。 容器,是一个运行时环境,就是我们前面说到的集装箱。可以对比mysql演示对比讲解
2.2.1、镜像(image)
Docker 镜像(Image)就是一个只读的模板。镜像可以用来创建 Docker 容器,一个镜像可以创建很多容器。
它也相当于是一个root文件系统。比如官方镜像 centos:7 就包含了完整的一套 centos:7 最小系统的 root 文件系统。
相当于容器的“源代码”,docker镜像文件类似于Java的类模板,而docker容器实例类似于java中new出来的实例对象。
2.2.2、容器(container)
1 从面向对象角度
Docker 利用容器(Container)独立运行的一个或一组应用,应用程序或服务运行在容器里面,容器就类似于一个虚拟化的运行环境,容器是用镜像创建的运行实例。就像是Java中的类和实例对象一样,镜像是静态的定义,容器是镜像运行时的实体。容器为镜像提供了一个标准的和隔离的运行环境,它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台
2 从镜像容器角度
可以把容器看做是一个简易版的 Linux 环境(包括root用户权限、进程空间、用户空间和网络空间等)和运行在其中的应用程序。
2.2.3、仓库(repository)
仓库(Repository)是集中存放镜像文件的场所。
类似于
Maven仓库,存放各种jar包的地方;
github仓库,存放各种git项目的地方;
Docker公司提供的官方registry被称为Docker Hub,存放各种镜像模板的地方。
仓库分为公开仓库(Public)和私有仓库(Private)两种形式。
最大的公开仓库是 Docker Hub(https://hub.docker.com/),
存放了数量庞大的镜像供用户下载。国内的公开仓库包括阿里云 、网易云等
2.2.4、小总结
需要正确的理解仓库/镜像/容器这几个概念:
Docker 本身是一个容器运行载体或称之为管理引擎。我们把应用程序和配置依赖打包好形成一个可交付的运行环境,这个打包好的运行环境就是image镜像文件。只有通过这个镜像文件才能生成Docker容器实例(类似Java中new出来一个对象)。
image文件可以看作是容器的模板。Docker 根据 image 文件生成容器的实例。同一个 image 文件,可以生成多个同时运行的容器实例。
镜像文件
- image 文件生成的容器实例,本身也是一个文件,称为镜像文件。
容器实例 - 一个容器运行一种服务,当我们需要的时候,就可以通过docker客户端创建一个对应的运行实例,也就是我们的容器
仓库 - 就是放一堆镜像的地方,我们可以把镜像发布到仓库中,需要的时候再从仓库中拉下来就可以了。
2.3、Docker平台架构图解(架构版)
先有大概轮廓,混个眼熟
整体架构及底层通信原理简述:
Docker 是一个 C/S 模式的架构,后端是一个松耦合架构,众多模块各司其职。
1 | 1用户是使用Docker Client与Docker Daemon建立通信,并发送请求给后者。 |
2.4、安装步骤
官方文档:Install Docker Engine on CentOS
2.4.1、确保centos版本为7及以上(本次7.9)
cat /etc/redhat-release
2.4.2、卸载旧版本
2.4.3、yum安装gcc相关包
保证系统能上外网
yum -y install gcc
yum -y install gcc-c++
2.4.4、安装需求的软件包
官网要求:
执行命令:yum install -y yum-utils
2.4.5、设置stable镜像仓库
注意:如果使用官网的可能会很慢或报错(访问外网速度很慢)
yum-config-manager –add-repo https://download.docker.com/linux/centos/docker-ce.repo
推荐:使用阿里云镜像仓库
yum-config-manager –add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
2.4.6、更新yum软件包索引
yum makecache fast
2.4.7、安装DOCKER CE
sudo yum install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
官网要求:
执行结果:
2.4.8、启动docker
systemctl start docker
查看启动状态:systemctl status docker
2.4.9、测试是否安装成功
docker version
docker run hello-world
2.4.10、卸载
systemctl stop docker
sudo yum remove docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras
sudo rm -rf /var/lib/docker
sudo rm -rf /var/lib/containerd
2.5、阿里云镜像加速
2.5.1、是什么
容器镜像服务_镜像构建_镜像授权_镜像托管-阿里云 (aliyun.com)
2.5.2、获得加速地址链接
登陆阿里云开发者平台
进入控制台
选择容器镜像服务
获取加速器地址
1 | sudo mkdir -p /etc/docker |
2.5.3、重启服务器
systemctl daemon-reload
systemctl restart docker
2.6、永远的helloworld
启动Docker后台容器(测试运行 hello-world)
2.6.1、docker run hello-world:
输出这段提示以后,hello world就会停止运行,容器自动终止。
2.6.2、run干了什么:
2.7、底层原理
为什么Docker会比VM虚拟机快
(1)docker有着比虚拟机更少的抽象层
由于docker不需要Hypervisor(虚拟机)实现硬件资源虚拟化,运行在docker容器上的程序直接使用的都是实际物理机的硬件资源。因此在CPU、内存利用率上docker将会在效率上有明显优势。
(2)docker利用的是宿主机的内核,而不需要加载操作系统OS内核
当新建一个容器时,docker不需要和虚拟机一样重新加载一个操作系统内核。进而避免引寻、加载操作系统内核返回等比较费时费资源的过程,当新建一个虚拟机时,虚拟机软件需要加载OS,返回新建过程是分钟级别的。而docker由于直接利用宿主机的操作系统,则省略了返回过程,因此新建一个docker容器只需要几秒钟。
3、Docker常用命令
3.1、帮助启动类命令
启动docker: systemctl start docker
停止docker: systemctl stop docker
重启docker: systemctl restart docker
查看docker状态: systemctl status docker
开机启动: systemctl enable docker
查看docker概要信息: docker info
查看docker总体帮助文档: docker –help
查看docker命令帮助文档: docker 具体命令 –help
3.2、镜像命令
3.2.1、docker images
列出本地主机上的镜像
各个选项说明:
REPOSITORY:表示镜像的仓库源
TAG:镜像的标签版本号
IMAGE ID:镜像ID
CREATED:镜像创建时间
SIZE:镜像大小
同一仓库源可以有多个 TAG版本,代表这个仓库源的不同个版本,我们使用 REPOSITORY:TAG 来定义不同的镜像。
如果你不指定一个镜像的版本标签,例如你只使用 ubuntu,docker 将默认使用 ubuntu:latest 镜像
OPTIONS说明:
-a :列出本地所有的镜像(含历史映像层)
-q :只显示镜像ID。
3.2.2、docker search 某个XXX镜像名字
命令:docker search [OPTIONS] 镜像名字
OPTIONS说明:–limit : 只列出N个镜像,默认25个 docker search –limit 5 redis
3.2.3、docker pull 某个XXX镜像名字
下载镜像
docker pull 镜像名字[:TAG]
docker pull 镜像名字:
没有TAG就是最新版 等价于 docker pull 镜像名字:latest
docker pull ubuntu
3.2.4、docker system df 查看镜像/容器/数据卷所占的空间
3.2.5、docker rmi 某个XXX镜像名字ID
删除镜像
删除单个:docker rmi -f 镜像ID
删除多个:docker rmi -f 镜像名1:TAG 镜像名2:TAG
删除全部:docker rmi -f $(docker images -qa)
3.2.6、面试题:谈谈docker虚悬镜像是什么?
是什么:仓库名、标签都是
长什么样:
后续Dockerfile章节再介绍
3.2.7、思考
结合我们Git的学习心得,大家猜猜是否会有
docker commit /docker push??
3.3、容器命令
有镜像才能创建容器,
这是根本前提(下载一个CentOS或者ubuntu镜像演示)
docker pull centos docker pull ubuntu
3.3.1、新建+启动容器
docker run [OPTIONS] IMAGE [COMMAND] [ARG…]
OPTIONS说明:
OPTIONS说明(常用):有些是一个减号,有些是两个减号
–name=”容器新名字” 为容器指定一个名称;
-d: 后台运行容器并返回容器ID,也即启动守护式容器(后台运行);
-i:以交互模式运行容器,通常与 -t 同时使用;
-t:为容器重新分配一个伪输入终端,通常与 -i 同时使用;
也即启动交互式容器(前台有伪终端,等待交互);
-P: 随机端口映射,大写P
-p: 指定端口映射,小写p
启动交互式容器(前台命令行):
#使用镜像centos:latest以交互模式启动一个容器,在容器内执行/bin/bash命令。
docker run -it centos /bin/bash
参数说明:
-i: 交互式操作。
-t: 终端。
centos : centos 镜像。
/bin/bash:放在镜像名后的是命令,这里我们希望有个交互式 Shell,因此用的是 /bin/bash。
要退出终端,直接输入 exit:
3.3.2、列出当前所有正在运行的容器
docker ps [OPTIONS]
OPTIONS说明:
OPTIONS说明(常用):
-a :列出当前所有正在运行的容器+历史上运行过的
-l :显示最近创建的容器。
-n:显示最近n个创建的容器。
-q :静默模式,只显示容器编号。
3.3.3、退出容器
两种退出方式:
exit :run进去容器,exit退出,容器停止
ctrl+p+q:run进去容器,ctrl+p+q退出,容器不停止
3.3.4、启动已停止运行的容器
docker start 容器ID或者容器名
3.3.5、重启容器
docker restart 容器ID或者容器名
3.3.6、停止容器
docker stop 容器ID或者容器名
3.3.7、强制停止容器
docker kill 容器ID或容器名
3.3.8、删除已停止的容器
docker rm 容器ID
一次性删除多个容器实例:
docker rm -f $(docker ps -a -q)
docker ps -a -q | xargs docker rm
3.3.9、重要
有镜像才能创建容器,这是根本前提(下载一个Redis6.0.8镜像演示)
启动守护式容器(后台服务器):
在大部分的场景下,我们希望 docker 的服务是在后台运行的,
我们可以过 -d 指定容器的后台运行模式。
docker run -d 容器名
1 | #使用镜像centos:latest以后台模式启动一个容器 |
redis 前后台启动演示case:
前台交互式启动: docker run -it redis:6.0.8
后台守护式启动:docker run -d redis:6.0.8
查看容器日志
docker logs 容器ID
查看容器内运行的进程
docker top 容器ID
查看容器内部细节
docker inspect 容器ID
进入正在运行的容器并以命令行交互
docker exec -it 容器ID bashShell
重新进入docker attach 容器ID
上述两个区别:
attach 直接进入容器启动命令的终端,不会启动新的进程
用exit退出,会导致容器的停止。
exec 是在容器中打开新的终端,并且可以启动新的进程
用exit退出,不会导致容器的停止。
推荐大家使用 docker exec 命令,因为退出容器终端,不会导致容器的停止。
用之前的redis容器实例进入试试:
进入redis服务
docker exec -it 容器ID /bin/bash
docker exec -it 容器ID redis-cli
一般用-d后台启动的程序,再用exec进入对应容器实例
从容器内拷贝文件到主机上
容器→主机
docker cp 容器ID:容器内路径 目的主机路径
导入和导出容器
export 导出容器的内容留作为一个tar归档文件[对应import命令]
import 从tar包中的内容创建一个新的文件系统再导入为镜像[对应export]
docker export 容器ID > 文件名.tar
cat 文件名.tar | docker import - 镜像用户/镜像名:镜像版本号
3.4、小总结
常用命令
attach Attach to a running container # 当前 shell 下 attach 连接指定运行镜像
build Build an image from a Dockerfile # 通过 Dockerfile 定制镜像
commit Create a new image from a container changes # 提交当前容器为新的镜像
cp Copy files/folders from the containers filesystem to the host path #从容器中拷贝指定文件或者目录到宿主机中
create Create a new container # 创建一个新的容器,同 run,但不启动容器
diff Inspect changes on a container’s filesystem # 查看 docker 容器变化
events Get real time events from the server # 从 docker 服务获取容器实时事件
exec Run a command in an existing container # 在已存在的容器上运行命令
export Stream the contents of a container as a tar archive # 导出容器的内容流作为一个 tar 归档文件[对应 import ]
history Show the history of an image # 展示一个镜像形成历史
images List images # 列出系统当前镜像
import Create a new filesystem image from the contents of a tarball # 从tar包中的内容创建一个新的文件系统映像[对应export]
info Display system-wide information # 显示系统相关信息
inspect Return low-level information on a container # 查看容器详细信息
kill Kill a running container # kill 指定 docker 容器
load Load an image from a tar archive # 从一个 tar 包中加载一个镜像[对应 save]
login Register or Login to the docker registry server # 注册或者登陆一个 docker 源服务器
logout Log out from a Docker registry server # 从当前 Docker registry 退出
logs Fetch the logs of a container # 输出当前容器日志信息
port Lookup the public-facing port which is NAT-ed to PRIVATE_PORT # 查看映射端口对应的容器内部源端口
pause Pause all processes within a container # 暂停容器
ps List containers # 列出容器列表
pull Pull an image or a repository from the docker registry server # 从docker镜像源服务器拉取指定镜像或者库镜像
push Push an image or a repository to the docker registry server # 推送指定镜像或者库镜像至docker源服务器
restart Restart a running container # 重启运行的容器
rm Remove one or more containers # 移除一个或者多个容器
rmi Remove one or more images # 移除一个或多个镜像[无容器使用该镜像才可删除,否则需删除相关容器才可继续或 -f 强制删除]
run Run a command in a new container # 创建一个新的容器并运行一个命令
save Save an image to a tar archive # 保存一个镜像为一个 tar 包[对应 load]
search Search for an image on the Docker Hub # 在 docker hub 中搜索镜像
start Start a stopped containers # 启动容器
stop Stop a running containers # 停止容器
tag Tag an image into a repository # 给源中镜像打标签
top Lookup the running processes of a container # 查看容器中运行的进程信息
unpause Unpause a paused container # 取消暂停容器
version Show the docker version information # 查看 docker 版本号
wait Block until a container stops, then print its exit code # 截取容器停止时的退出状态值
4、Docker images
4.1、是什么
4.1.1、概念
镜像
是一种轻量级、可执行的独立软件包,它包含运行某个软件所需的所有内容,我们把应用程序和配置依赖打包好形成一个可交付的运行环境(包括代码、运行时需要的库、环境变量和配置文件等),这个打包好的运行环境就是image镜像文件。
只有通过这个镜像文件才能生成Docker容器实例(类似Java中new出来一个对象)。
4.1.2、分层的镜像
以我们的pull为例,在下载的过程中我们可以看到docker的镜像好像是在一层一层的在下载
4.1.3、UnionFS(联合文件系统)
UnionFS(联合文件系统):Union文件系统(UnionFS)是一种分层、轻量级并且高性能的文件系统,它支持对文件系统的修改作为一次提交来一层层的叠加,同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。Union 文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承,基于基础镜像(没有父镜像),可以制作各种具体的应用镜像。
特性:一次同时加载多个文件系统,但从外面看起来,只能看到一个文件系统,联合加载会把各层文件系统叠加起来,这样最终的文件系统会包含所有底层的文件和目录
4.1.4、 Docker镜像加载原理
Docker镜像加载原理:
docker的镜像实际上由一层一层的文件系统组成,这种层级的文件系统UnionFS。
bootfs(boot file system)主要包含bootloader和kernel, bootloader主要是引导加载kernel, Linux刚启动时会加载bootfs文件系统,在Docker镜像的最底层是引导文件系统bootfs。这一层与我们典型的Linux/Unix系统是一样的,包含boot加载器和内核。当boot加载完成之后整个内核就都在内存中了,此时内存的使用权已由bootfs转交给内核,此时系统也会卸载bootfs。
rootfs (root file system) ,在bootfs之上。包含的就是典型 Linux 系统中的 /dev, /proc, /bin, /etc 等标准目录和文件。rootfs就是各种不同的操作系统发行版,比如Ubuntu,Centos等等。
平时我们安装进虚拟机的CentOS都是好几个G,为什么docker这里才200M??
对于一个精简的OS,rootfs可以很小,只需要包括最基本的命令、工具和程序库就可以了,因为底层直接用Host的kernel,自己只需要提供 rootfs 就行了。由此可见对于不同的linux发行版, bootfs基本是一致的, rootfs会有差别, 因此不同的发行版可以公用bootfs。
4.1.5、为什么 Docker 镜像要采用这种分层结构呢
镜像分层最大的一个好处就是共享资源,方便复制迁移,就是为了复用。
比如说有多个镜像都从相同的 base 镜像构建而来,那么 Docker Host 只需在磁盘上保存一份 base 镜像;
同时内存中也只需加载一份 base 镜像,就可以为所有容器服务了。而且镜像的每一层都可以被共享。
4.2、重点理解
Docker镜像层都是只读的,容器层是可写的
当容器启动时,一个新的可写层被加载到镜像的顶部。
这一层通常被称作“容器层”,“容器层”之下的都叫“镜像层”。
当容器启动时,一个新的可写层被加载到镜像的顶部。这一层通常被称作“容器层”,“容器层”之下的都叫“镜像层”。
所有对容器的改动 - 无论添加、删除、还是修改文件都只会发生在容器层中。只有容器层是可写的,容器层下面的所有镜像层都是只读的。
4.3、Docker镜像commit操作案例
docker commit提交容器副本使之成为一个新的镜像、
docker commit -m=”提交的描述信息” -a=”作者” 容器ID 要创建的目标镜像名:[标签名]
4.3.1、案例演示ubuntu安装vim
从Hub上下载ubuntu镜像到本地并成功运行:
docker pull ubuntu
原始的默认Ubuntu镜像是不带着vim命令的:
外网连通的情况下,安装vim:
docker容器内执行上述两条命令:
apt-get update
apt-get -y install vim
安装完成后,commit我们自己的新镜像:
启动我们的新镜像并和原来的对比:
1 官网是默认下载的Ubuntu没有vim命令
2我们自己commit构建的镜像,新增加了vim功能,可以成功使用。
4.3.2、小总结
Docker中的镜像分层,支持通过扩展现有镜像,创建新的镜像。类似Java继承于一个Base基础类,自己再按需扩展。
新镜像是从 base 镜像一层一层叠加生成的。每安装一个软件,就在现有镜像的基础上增加一层
5、本地镜像发布到阿里云
5.1、本地镜像发布到阿里云流程
5.2、镜像的生成方法
基于当前容器创建一个新的镜像,新功能增强
docker commit [OPTIONS] 容器ID [REPOSITORY[:TAG]]
后面的DockerFile章节,有第2种方法
5.3、将本地镜像推送到阿里云
5.3.1、素材原型
5.3.2、阿里云开发者平台
5.3.3、创建仓库镜像
选择控制台,进入容器镜像服务
选择个人实例
进入命名空间:
创建命名空间:
仓库名称:
进入管理界面获得脚本:
5.3.4、将镜像推送到阿里云
将镜像推送到阿里云registry
5.4、将阿里云上的镜像下载到本地
1 | docker pull registry.cn-hangzhou.aliyuncs.com/xiao-lin/myubuntu:[镜像版本号] |
6、将本地镜像推送到私有仓库
6.1、本地镜像发布到私有库流程
6.2、是什么
1 官方Docker Hub地址:https://hub.docker.com/,中国大陆访问太慢了且准备被阿里云取代的趋势,不太主流。
2 Dockerhub、阿里云这样的公共镜像仓库可能不太方便,涉及机密的公司不可能提供镜像给公网,所以需要创建一个本地私人仓库供给团队使用,基于公司内部项目构建镜像。
Docker Registry是官方提供的工具,可以用于构建私有镜像仓库
6.3、将本地镜像推送到私有库
6.3.1、下载镜像Docker Registry
docker pull registry
6.3.2、运行私有库Registry,相当于本地有个私有Docker hub
docker run -d -p 5000:5000 -v /zzyyuse/myregistry/:/tmp/registry –privileged=true registry
默认情况,仓库被创建在容器的/var/lib/registry目录下,建议自行用容器卷映射,方便于宿主机联调
6.3.3、案例演示创建一个新镜像,ubuntu安装ifconfig命令
从Hub上下载ubuntu镜像到本地并成功运行:
docker pull ubuntu
docker run -it ubuntu /bin/bash
原始的Ubuntu镜像是不带着ifconfig命令的:
外网连通的情况下,安装ifconfig命令并测试通过:
docker容器内执行上述两条命令:
apt-get update
apt-get install net-tools
安装完成后,commit我们自己的新镜像:
公式:
docker commit -m=”提交的描述信息” -a=”作者” 容器ID 要创建的目标镜像名:[标签名]
命令:在容器外执行,记得
docker commit -m=”ifconfig cmd add” -a=”zzyy” a69d7c825c4f zzyyubuntu:1.2
启动我们的新镜像并和原来的对比:
1 官网是默认下载的Ubuntu没有ifconfig命令
2我们自己commit构建的新镜像,新增加了ifconfig功能,可以成功使用。
6.3.4、curl验证私服库上有什么镜像
curl -XGET http://8.130.115.225:5000/v2/_catalog
可以看到,目前私服库没有任何镜像上传过
6.3.5、将新镜像zzyyubuntu:1.2修改符合私服规范的Tag
按照公式: docker tag 镜像:Tag Host:Port/Repository:Tag
自己host主机IP地址,填写自己的,不要粘贴错误,O(∩_∩)O
使用命令 docker tag 将zzyyubuntu:1.2 这个镜像修改为192.168.111.162:5000/zzyyubuntu:1.2
docker tag zzyyubuntu:1.2 192.168.111.162:5000/zzyyubuntu:1.2
6.3.6、修改配置文件使之支持http
别无脑照着复制,registry-mirrors 配置的是国内阿里提供的镜像加速地址,不用加速的话访问官网的会很慢。
2个配置中间有个逗号 ‘,’别漏了,这个配置是json格式的。
vim命令新增如下红色内容:vim /etc/docker/daemon.json
1 | { |
上述理由:docker默认不允许http方式推送镜像,通过配置选项来取消这个限制。====> 修改完后如果不生效,建议重启docker
systemctl restart docker
6.3.7、push推送到私服库
docker push 8.130.115.225:5000/xiaolinubuntu:1.2
6.3.8、curl验证私服库上有什么镜像2
curl -XGET http://8.130.115.225:5000/v2/_catalog
6.3.9、pull到本地并运行
docker pull 8.130.115.225:5000/xiaolinubuntu:1.2
docker run -it 镜像ID /bin/bash
7、Docker 容器数据卷
7.1、坑:容器卷记得加入 –privileged=true :
why:
Docker挂载主机目录访问如果出现cannot open directory .: Permission denied
解决办法:在挂载目录后多加一个–privileged=true参数即可
如果是CentOS7安全模块会比之前系统版本加强,不安全的会先禁止,所以目录挂载的情况被默认为不安全的行为,
在SELinux里面挂载目录被禁止掉了额,如果要开启,我们一般使用–privileged=true命令,扩大容器的权限解决挂载目录没有权限的问题,也即
使用该参数,container内的root拥有真正的root权限,否则,container内的root只是外部的一个普通用户权限。
7.2、上节的参数v
7.3、是什么
卷就是目录或文件,存在于一个或多个容器中,由docker挂载到容器,但不属于联合文件系统,因此能够绕过Union File System提供一些用于持续存储或共享数据的特性:
卷的设计目的就是数据的持久化,完全独立于容器的生存周期,因此Docker不会在容器删除时删除其挂载的数据卷
一句话:有点类似我们Redis里面的rdb和aof文件
将docker容器内的数据保存进宿主机的磁盘中
运行一个带有容器卷存储功能的容器实例
docker run -it –privileged=true -v /宿主机绝对路径目录:/容器内目录 镜像名
7.4、能干嘛
- 将运用与运行的环境打包镜像,run后形成容器实例运行 ,但是我们对数据的要求希望是持久化的
Docker容器产生的数据,如果不备份,那么当容器实例删除后,容器内的数据自然也就没有了。
为了能保存数据在docker中我们使用卷。
特点:
1:数据卷可在容器之间共享或重用数据
2:卷中的更改可以直接实时生效,爽
3:数据卷中的更改不会包含在镜像的更新中
4:数据卷的生命周期一直持续到没有容器使用它为止
7.5、数据卷案例
7.5.1、宿主vs容器之间映射添加容器卷
直接命令添加:
公式:docker run -it -v /宿主机目录:/容器内目录 ubuntu /bin/bash
1 | docker run -it --name myu3 --privileged=true -v /tmp/myHostData:/tmp/myDockerData ubuntu /bin/bash |
docker run -it –privileged=true -v /宿主机绝对路径目录:/容器内目录 镜像名
查看数据卷是否挂载成功:
docker inspect 容器ID
容器和宿主机之间数据共享:
1 docker修改,主机同步获得
2 主机修改,docker同步获得
3 docker容器stop,主机修改,docker容器重启看数据是否同步。
7.5.2、读写规则映射添加说明
读写(默认)
rw = read + write
docker run -it –privileged=true -v /宿主机绝对路径目录:/容器内目录:rw 镜像名
默认同上案例,默认就是rw
只读:容器实例内部被限制,只能读取不能写
/容器目录:ro 镜像名 就能完成功能,此时容器自己只能读取不能写
ro = read only
此时如果宿主机写入内容,可以同步给容器内,容器可以读取到。
docker run -it –privileged=true -v /宿主机绝对路径目录:/容器内目录:ro 镜像名
7.5.3、卷的继承和共享
容器1完成和宿主机的映射:
docker run -it –privileged=true -v /mydocker/u:/tmp –name u1 ubuntu
容器2继承容器1的卷规则:
docker run -it –privileged=true –volumes-from 父类 –name u2 ubuntu
此时的u1和u2只是规则相同,u1和u2存活与否互不干涉
8、Docker常规安装简介
8.1、总体步骤
- 搜索镜像
- 拉取镜像
- 查看镜像
- 启动镜像-服务端口映射
- 停止容器
- 移除容器
8.2、安装tomcat
8.2.1、docker hub上面查找tomcat镜像
docker search tomcat
8.2.2、从docker hub上拉取tomcat镜像到本地
docker pull tomcat
8.2.3、docker images查看是否有拉取到的tomcat
8.2.4、使用tomcat镜像创建容器实例(也叫运行镜像)
docker run -it -p 8080:8080 tomcat
-p 小写,主机端口:docker容器端口
-P 大写,随机分配端口
i:交互 t:终端
d:后台
8.2.5、访问猫首页
问题:
解决:
①可能没有映射端口或者没有关闭防火墙
②把webapps.dist目录换成webapps:
先成功启动tomcat
查看webapps 文件夹查看为空
8.2.6、免修改版说明
docker pull billygoo/tomcat8-jdk8
docker run -d -p 8080:8080 –name mytomcat8 billygoo/tomcat8-jdk8
8.3、安装mysql
8.3.1、docker hub上面查找mysql镜像
8.3.2、从docker hub上(阿里云加速器)拉取mysql镜像到本地标签为5.7
8.3.3、使用mysql5.7镜像创建容器(也叫运行镜像)
命令出处,哪里来的?
简单版:
使用mysql镜像
1 | docker run -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7 |
建库建表插入数据:
外部主机也来连接运行在dokcer上的mysql容器实例服务
问题:
插入中文数据试试
为什么报错?
①docker上默认字符集编码隐患
docker里面的mysql容器实例查看,内容如下:
SHOW VARIABLES LIKE ‘character%’;
删除容器后,里面的mysql数据如何办
②容器实例一删除,你还有什么?
删容器到跑路。。。。。?
实战版:
新建mysql容器实例:
1 | docker run -d -p 3306:3306 --privileged=true -v /xiaolin/mysql/log:/var/log/mysql -v /xiaolin/mysql/data:/var/lib/mysql -v /xiaolin/mysql/conf:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=123456 --name mysql mysql:5.7 |
新建my.cnf:
通过容器卷同步给mysql容器实例
1 | [client] |
重新启动mysql容器实例再重新进入并查看字符编码
再新建库新建表再插入中文测试:
结论:
之前的DB 无效
修改字符集操作+重启mysql容器实例
之后的DB 有效,需要新建
结论:docker安装完MySQL并run出容器后,建议请先修改完字符集编码后再新建mysql库-表-插数据
假如将当前容器实例删除,再重新来一次,之前建的db01实例还有吗?trytry
因为挂载了容器卷,所以重新run一个实例时,数据会重新加载,不会丢失
8.4、安装redis
8.4.1、从docker hub上(阿里云加速器)拉取redis镜像到本地标签为6.0.8
8.4.2、入门命令
8.4.3、命令提醒:容器卷记得加入–privileged=true
Docker挂载主机目录Docker访问出现cannot open directory .: Permission denied
解决办法:在挂载目录后多加一个–privileged=true参数即可
8.4.4、在CentOS宿主机下新建目录/app/redis
1 建目录
mkdir -p /app/redis
8.4.5、将一个redis.conf文件模板拷贝进/app/redis目录下
2 拷贝配置文件
将准备好的redis.conf文件放进/app/redis目录下
8.4.6、/app/redis目录下修改redis.conf文件
3 /app/redis目录下修改redis.conf文件
3.1 开启redis验证 可选
requirepass 123
3.2 允许redis外地连接 必须
注释掉 # bind 127.0.0.1
3.3 daemonize no
将daemonize yes注释起来或者 daemonize no设置,因为该配置和docker run中-d参数冲突,会导致容器一直启动失败
3.4 开启redis数据持久化 appendonly yes 可选
默认出厂的原始redis.conf:
1 | # Redis configuration file example. |
8.4.7、使用redis6.0.8镜像创建容器(也叫运行镜像)
1 | docker run -p 6379:6379 --name myr3 --privileged=true -v /app/redis/redis.conf:/etc/redis/redis.conf -v /app/redis/data:/data -d redis:6.0.8 redis-server /etc/redis/redis.conf |
8.4.8、测试redis-cli连接上来
docker exec -it 运行着Rediis服务的容器ID redis-cli
8.4.9、证明docker启动使用了我们自己指定的配置文件
修改前:
修改后:
记得重启服务
8.4.10、测试redis-cli连接上来第2次
8.5、安装Nginx
Docker 安装 Nginx 容器 (完整详细版)_docker nginx_Touch&的博客-CSDN博客
8.5.1、搜索然后下载镜像并查看
1 | docker search nginx |
8.5.2、创建容器卷映射地址(保存nginx相关配置)
1 |
|
8.5.3、把容器中的相关配置文件复制到宿主机
1 | # 生成容器 |
8.5.4、运行nginx容器
1 |
|
1 | docker run \ |
1 | docker run -p 80:80 --name my-nginx -v /xiaolin/nginx/conf/nginx.conf:/etc/nginx/nginx.conf -v /xiaolin/nginx/conf/conf.d:/etc/nginx/conf.d -v /xiaolin/nginx/log:/var/log/nginx -v /xiaolin/nginx/html:/usr/share/nginx/html -d nginx:latest |
8.5.5、访问
8.130.115.225
8.5.6、修改内容进行展示
vim /xiaolin/nginx/html/index.html
然后重启
二、高级篇
1、Docker复杂安装详说
1.1、安装mysql主从复制
1.1.1、主从复制原理
MySQL主从复制是指将一个MySQL数据库的数据复制到另一个MySQL数据库的过程。主库(master)是指数据源,从库(slave)是指数据接收方。主从复制的原理如下:
主库将数据变更记录到二进制日志(binlog)中。
从库连接主库,并请求从指定的位置开始获取主库的binlog。
主库将binlog传给从库,从库将binlog写入本地的中继日志(relay log)中。
从库读取中继日志,将其中的变更应用到本地的数据库中。
从库定期向主库发送心跳包,以便主库检测从库的状态。
当主库发生变更时,从库将会收到通知,然后根据通知的信息获取相应的binlog,并将其应用到本地的数据库中。
通过这种方式,主库和从库之间可以保持数据的同步,从而实现数据的备份、负载均衡等功能。
1.1.2、主从搭建步骤
新建主服务器容器实例3307
1
2
3
4
5
6
7
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进入/mydata/mysql-master/conf目录下新建my.cnf
vim my.cnf
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16[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=10621
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37MySQL的my.cnf配置文件是MySQL服务器的主要配置文件,它包含了MySQL服务器的各种配置参数,可以通过修改配置参数来改变MySQL服务器的行为,从而满足不同的需求。下面是my.cnf配置文件中常用的配置参数及其详细解释:
1. [client]:客户端配置参数,包括连接MySQL服务器的相关参数,如host、user、password等。
2. [mysqld]:MySQL服务器配置参数,包括MySQL服务器的启动参数、缓存参数、日志参数、安全参数等。
3. datadir:MySQL数据库文件存放的路径。
4. port:MySQL服务器监听的端口号。
5. server-id:MySQL服务器的唯一标识符,在主从复制中用于标识主库和从库。
6. log-bin:启用二进制日志功能,用于主从复制和数据恢复。
7. log-error:MySQL服务器错误日志文件的路径。
8. max_connections:MySQL服务器最大连接数。
9. character-set-server:MySQL服务器默认字符集。
10. innodb_buffer_pool_size:InnoDB存储引擎缓存池大小。
11. innodb_log_file_size:InnoDB存储引擎日志文件大小。
12. innodb_flush_log_at_trx_commit:InnoDB存储引擎日志刷写策略。
13. skip-name-resolve:禁止MySQL服务器进行DNS解析,提高性能。
14. skip-external-locking:禁止MySQL服务器使用外部锁功能,提高性能。
15. slow_query_log:启用慢查询日志功能,用于诊断慢查询。
16. long_query_time:慢查询日志的阈值,超过该时间的查询将被记录。
17. log-slow-queries:慢查询日志文件的路径。
以上是my.cnf配置文件中常用的配置参数及其详细解释,根据实际需求可以灵活配置。修改完配置后重启master实例
docker restart mysql-master
进入mysql-master容器
docker exec -it mysql-master /bin/bash
mysql -uroot -proot
master容器实例内创建数据同步用户
CREATE USER ‘slave‘@’%’ IDENTIFIED BY ‘123456’;
GRANT REPLICATION SLAVE, REPLICATION CLIENT ON . TO ‘slave‘@’%’;
新建从服务器容器实例3308
1
2
3
4
5
6docker 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进入/mydata/mysql-slave/conf目录下新建my.cnf
vim my.cnf
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23[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
## relay_log配置中继日志
relay_log=mall-mysql-relay-bin
## log_slave_updates表示slave将复制事件写进自己的二进制日志
log_slave_updates=1
## slave设置为只读(具有super权限的用户除外)
read_only=11
2
3
4
5
6
7
8
9
10
11
12
13
14
15MySQL支持三种二进制日志格式:statement、row和mixed。设置使用的二进制日志格式可以通过修改my.cnf配置文件中的binlog_format参数来实现。
1. statement格式:记录SQL语句
statement格式是最简单的二进制日志格式,它记录的是MySQL服务器接收到的SQL语句。这种格式的优点是记录量较小,缺点是不能记录数据变更前后的值,也不能记录一些特殊的SQL语句,如UUID()等。
2. row格式:记录行数据
row格式是最详细的二进制日志格式,它记录每一行数据的变更情况,包括变更前后的值。这种格式的优点是记录非常详细,可以用于数据恢复和主从复制,缺点是记录量较大,可能会影响性能。
3. mixed格式:混合记录SQL语句和行数据
mixed格式是statement格式和row格式的结合,它根据SQL语句的不同自动选择记录SQL语句或行数据。这种格式的优点是既能记录SQL语句,又能记录行数据,可以充分发挥两种格式的优点,缺点是可能会产生一些复杂的日志记录。
综上所述,选择哪种二进制日志格式取决于实际需求。如果需要记录详细的数据变更信息,可以选择row格式;如果需要记录SQL语句并保证性能,可以选择statement格式;如果需要兼顾两者的优点,可以选择mixed格式。修改完配置后重启slave实例
docker restart mysql-slave
在主数据库中查看主从同步状态
show master status;
进入mysql-slave容器
docker exec -it mysql-slave /bin/bash
mysql -uroot -proot
在从数据库中配置主从复制
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;
主从复制命令参数说明:
1
2
3
4
5
6
7master_host:主数据库的IP地址;
master_port:主数据库的运行端口;
master_user:在主数据库创建的用于同步数据的用户账号;
master_password:在主数据库创建的用于同步数据的用户密码;
master_log_file:指定从数据库要复制数据的日志文件,通过查看主数据的状态,获取File参数;
master_log_pos:指定从数据库从哪个位置开始复制数据,通过查看主数据的状态,获取Position参数;
master_connect_retry:连接失败重试的时间间隔,单位为秒。在从数据库中查看主从同步状态
show slave status \G;
在从数据库中开启主从同步
查看从数据库状态发现已经同步
主从复制测试
主机新建库-使用库-新建表-插入数据,ok
从机使用库-查看记录,ok
1.2、安装redis集群(大厂面试题第4季-分布式存储案例真题)
cluster(集群)模式-docker版
哈希槽分区进行亿级数据存储
1.2.1、面试题
1~2亿条数据需要缓存,请问如何设计这个存储案例
回答:单机单台100%不可能,肯定是分布式存储,用redis如何落地?
上述问题阿里P6~P7工程案例和场景设计类必考题目,
一般业界有3种解决方案:
哈希取余分区
2亿条记录就是2亿个k,v,我们单机不行必须要分布式多机,假设有3台机器构成一个集群,用户每次读写操作都是根据公式:
hash(key) % N个机器台数,计算出哈希值,用来决定数据映射到哪一个节点上。优点:
简单粗暴,直接有效,只需要预估好数据规划好节点,例如3台、8台、10台,就能保证一段时间的数据支撑。使用Hash算法让固定的一部分请求落到同一台服务器上,这样每台服务器固定处理一部分请求(并维护这些请求的信息),起到负载均衡+分而治之的作用。缺点:
原来规划好的节点,进行扩容或者缩容就比较麻烦了额,不管扩缩,每次数据变动导致节点有变动,映射关系需要重新进行计算,在服务器个数固定不变时没有问题,如果需要弹性扩容或故障停机的情况下,原来的取模公式就会发生变化:Hash(key)/3会变成Hash(key) /?。此时地址经过取余运算的结果将发生很大变化,根据公式获取的服务器也会变得不可控。
某个redis机器宕机了,由于台数数量变化,会导致hash取余全部数据重新洗牌。一致性哈希算法分区
是什么:
1
2
3一致性Hash算法背景
一致性哈希算法在1997年由麻省理工学院中提出的,设计目标是为了解决
分布式缓存数据变动和映射问题,某个机器宕机了,分母数量改变了,自然取余数不OK了能干嘛:
提出一致性Hash解决方案。
目的是当服务器个数发生变动时,
尽量减少影响客户端到服务器的映射关系3大步骤:
算法构建一致性哈希环
1
2
3
4一致性哈希环
一致性哈希算法必然有个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环。服务器IP节点映射
1
2
3节点映射
将集群中各个IP节点映射到环上的某一个位置。
将各个服务器使用Hash进行一个哈希,具体可以选择服务器的IP或主机名作为关键字进行哈希,这样每台机器就能确定其在哈希环上的位置。假如4个节点NodeA、B、C、D,经过IP地址的哈希函数计算(hash(ip)),使用IP地址哈希后在环空间的位置如下:key落到服务器的落键规则
1
2当我们需要存储一个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
2容错性
假设Node C宕机,可以看到此时对象A、B、D不会受到影响,只有C对象被重定位到Node D。一般的,在一致性Hash算法中,如果一台服务器不可用,则受影响的数据仅仅是此服务器到其环空间中前一台服务器(即沿着逆时针方向行走遇到的第一台服务器)之间数据,其它不会受到影响。简单说,就是C挂了,受到影响的只是B、C之间的数据,并且这些数据会转移到D进行存储。一致性哈希算法的扩展性
1
2
3扩展性
数据量增加了,需要增加一台节点NodeX,X的位置在A和B之间,那收到影响的也就是A到X之间的数据,重新把A到X的数据录入到X上即可,
不会导致hash取余全部数据重新洗牌。
缺点:
一致性哈希算法的数据倾斜问题
1
2
3Hash环的数据倾斜问题
一致性Hash算法在服务节点太少时,容易因为节点分布不均匀而造成数据倾斜(被缓存的对象大部分集中缓存在某一台服务器上)问题,
例如系统中只有两台服务器:
小总结:
1
2
3
4
5
6
7
8
9
10为了在节点数目发生改变时尽可能少的迁移数据
将所有的存储节点排列在收尾相接的Hash环上,每个key在计算Hash后会顺时针找到临近的存储节点存放。
而当有节点加入或退出时仅影响该节点在Hash环上顺时针相邻的后续节点。
优点
加入和删除节点只影响哈希环中顺时针方向的相邻的节点,对其他节点无影响。
缺点
数据的分布和节点的位置有关,因为这些节点不是均匀的分布在哈希环上的,所以数据在进行存储时达不到均匀分布的效果。哈希槽分区
是什么
1 为什么出现
哈希槽实质就是一个数组,数组[0,2^14 -1]形成hash slot空间。
2 能干什么
解决均匀分配的问题,在数据和节点之间又加入了一层,把这层称为哈希槽(slot),用于管理数据和节点之间的关系,现在就相当于节点上放的是槽,槽里放的是数据。槽解决的是粒度问题,相当于把粒度变大了,这样便于数据移动。
哈希解决的是映射问题,使用key的哈希值来计算所在的槽,便于数据分配。3 多少个hash槽
一个集群只能有16384个槽,编号0-16383(0-2^14-1)。这些槽会分配给集群中的所有主节点,分配策略没有要求。可以指定哪些编号的槽分配给哪个主节点。集群会记录节点和槽的对应关系。解决了节点和槽的关系后,接下来就需要对key求哈希值,然后对16384取余,余数是几key就落入对应的槽里。slot = CRC16(key) % 16384。以槽为单位移动数据,因为槽的数目是固定的,处理起来比较容易,这样数据移动问题就解决了。哈希槽计算
Redis 集群中内置了 16384 个哈希槽,redis 会根据节点数量大致均等的将哈希槽映射到不同的节点。当需要在 Redis 集群中放置一个 key-value时,redis 先对 key 使用 crc16 算法算出一个结果,然后把结果对 16384 求余数,这样每个 key 都会对应一个编号在 0-16383 之间的哈希槽,也就是映射到某个节点上。如下代码,key之A 、B在Node2, key之C落在Node3上
1.2.2、3主3从redis集群扩缩容配置案例架构说明
1.2.3、开打步骤
3主3从redis集群配置
1、关闭防火墙+启动docker后台服务
注意启动服务:systemctl start docker
2、新建6个docker容器redis实例:
1
2
3
4
5
6
7
8
9
10
11
12docker 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
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
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
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
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
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效果如下:
命令分步解释:
1
2
3
4
5
6
7
8
9docker run:创建并运行docker容器实例
--name redis-node-6:容器名字
--net host:使用宿主机的IP和端口,默认
--privileged=true:获取宿主机root用户权限
-v /data/redis/share/redis-node-6:/data:容器卷,宿主机地址:docker内部地址
redis:6.0.8:redis镜像和版本号
--cluster-enabled yes:开启redis集群
--appendonly yes:开启持久化
--port 6386:redis端口号3、进入容器redis-node-1并为6台机器构建集群关系:
进入容器:docker exec -it redis-node-1 /bin/bash
构建主从关系:
1
2//注意,进入docker容器后才能执行一下命令,且注意自己的真实IP地址
redis-cli --cluster create 8.130.115.225:6381 8.130.115.225:6382 8.130.115.225:6383 8.130.115.225:6384 8.130.115.225:6385 8.130.115.225:6386 --cluster-replicas 1–cluster-replicas 1 表示为每个master创建一个slave节点
一切OK的话,3主3从搞定
4、链接进入6381作为切入点,查看集群状态
链接进入6381作为切入点,查看节点状态
cluster info
cluster nodes
主从容错切换迁移案例
1、数据读写存储
启动6机构成的集群并通过exec进入
对6381新增两个key
防止路由失效加参数-c并新增两个key
查看集群信息
redis-cli –cluster check 8.130.115.225:6381
2、容错切换迁移
主6381和从机切换,先停止主机6381
6381主机停了,对应的真实从机上位
6381作为1号主机分配的从机以实际情况为准,具体是几号机器就是几号
再次查看集群信息:
6381宕机了,6384上位成为了新的master。
先还原之前的3主3从::
1
2
3docker start redis-node-1
docker stop redis-node-4
docker start redis-node-4主从机器分配情况以实际情况为准
查看集群状态:
redis-cli –cluster check 自己IP:6381
主从扩容案例
1、新建6387、6388两个节点+新建后启动+查看是否8节点
1
2
3
4
5docker 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
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
docker ps2、进入6387容器实例内部
1
docker exec -it redis-node-7 /bin/bash
3、将新增的6387节点(空槽号)作为master节点加入原集群
1
redis-cli --cluster add-node 8.130.115.225:6387 8.130.115.225:6381
4、检查集群情况第1次
1
redis-cli --cluster check 真实ip地址:6381
此时没有槽号
5、重新分派槽号
1
2
3
4重新分派槽号
命令:redis-cli --cluster reshard IP地址:端口号
redis-cli --cluster reshard 8.130.115.225:63816、检查集群情况第2次
redis-cli –cluster check 真实ip地址:6381
1
2
3槽号分派说明:
为什么6387是3个新的区间,以前的还是连续?
重新分配成本太高,所以前3家各自匀出来一部分,从6381/6382/6383三个旧节点分别匀出1364个坑位给新节点63877、为主节点6387分配从节点6388
1
2
3命令:redis-cli --cluster add-node ip:新slave端口 ip:新master端口 --cluster-slave --cluster-master-id 新主机节点ID
redis-cli --cluster add-node 8.130.115.225:6388 8.130.115.225:6387 --cluster-slave --cluster-master-id 7519e1479f230716f40ed365fe8a30d2a809fa2a-------这个是6387的编号,按照自己实际情况8、检查集群情况第3次
redis-cli –cluster check 8.130.115.225:6381
主从缩容案例
目的:6387和6388下线
检查集群情况1获得6388的节点ID:redis-cli –cluster check 8.130.115.225:6381
将6388删除
从集群中将4号从节点6388删除:将6387的槽号清空,重新分配,本例将清出来的槽号都给6381:
redis-cli –cluster reshard 8.130.115.225:6381
检查集群情况第二次:
redis-cli –cluster check 8.130.115.225:6381
4096个槽位都指给6381,它变成了8192个槽位,相当于全部都给6381了,不然要输入3次,一锅端
将6387删除:
命令:redis-cli –cluster del-node ip:端口 6387节点ID
redis-cli –cluster del-node 192.168.111.147:6387 e4781f644d4a4e4d4b4d107157b9ba8144631451
检查集群情况第三次:
redis-cli –cluster check 8.130.115.225:6381
2、DockeFile解析
2.1、是什么
Dockerfile是用来构建Docker镜像的文本文件,是由一条条构建镜像所需的指令和参数构成的脚本。
2.1.1、概述
2.1.2、官网
https://docs.docker.com/engine/reference/builder/
2.1.3、构建三步骤
编写Dockerfile文件
docker build命令构建镜像
docker run依镜像运行容器实例
2.2、DockerFile构建过程解析
2.2.1、Dockerfile内容基础知识
1:每条保留字指令都必须为大写字母且后面要跟随至少一个参数
2:指令按照从上到下,顺序执行
3:#表示注释
4:每条指令都会创建一个新的镜像层并对镜像进行提交
2.2.2、Docker执行Dockerfile的大致流程
(1)docker从基础镜像运行一个容器
(2)执行一条指令并对容器作出修改
(3)执行类似docker commit的操作提交一个新的镜像层
(4)docker再基于刚提交的镜像运行一个新容器
(5)执行dockerfile中的下一条指令直到所有指令都执行完成
2.2.3、小总结
从应用软件的角度来看,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常用保留字指令
2.3.1、参考tomcat8的dockerfile入门
https://github.com/docker-library/tomcat
2.3.2、FROM
基础镜像,当前新镜像是基于哪个镜像的,指定一个已经存在的镜像作为模板,第一条必须是from
2.3.3、MAINTAINER
镜像维护者的姓名和邮箱地址
已弃用,改用LABEL maintainer=”xxxx”
2.3.4、RUN
容器构建时需要运行的命令
两种格式:
shell格式
RUN yum -y install vim
exec格式
RUN是在 docker build时运行
2.3.5、EXPOSE
当前容器对外暴露出的端口
2.3.6、WORKDIR
指定在创建容器后,终端默认登陆的进来工作目录,一个落脚点
docker exec -it xxx bash进入之后的目录。
2.3.7、USER
指定该镜像以什么样的用户去执行,如果都不指定,默认是root
2.3.8、ENV
用来在构建镜像过程中设置环境变量
ENV MY_PATH /usr/mytest
这个环境变量可以在后续的任何RUN指令中使用,这就如同在命令前面指定了环境变量前缀一样;
也可以在其它指令中直接使用这些环境变量,
比如:WORKDIR $MY_PATH
2.3.9、ADD
将宿主机目录下的文件拷贝进镜像且会自动处理URL和解压tar压缩包
2.3.10、COPY
类似ADD,拷贝文件和目录到镜像中。
将从构建上下文目录中 <源路径> 的文件/目录复制到新的一层的镜像内的 <目标路径> 位置
COPY src dest或COPY [“src”, “dest”]
<src源路径>:源文件或者源目录
<dest目标路径>:容器内的指定路径,该路径不用事先建好,路径不存在的话,会自动创建。
2.3.11、VOLUME
容器数据卷,用于数据保存和持久化工作
2.3.12、CMD
指定容器启动后的要干的事情
注意:
Dockerfile 中可以有多个 CMD 指令,但只有最后一个生效,CMD 会被 docker run 之后的参数替换
参考官网Tomcat的dockerfile演示讲解
官网最后一行命令
我们演示自己的覆盖操作:
这样tomcat不会真正启动,只是启动了一个窗口
它和前面RUN命令的区别:
CMD是在docker run 时运行。
RUN是在 docker build时运行。
2.3.13、ENTRYPOINT
也是用来指定一个容器启动时要运行的命令
类似于 CMD 指令,但是ENTRYPOINT不会被docker run后面的命令覆盖,
而且这些命令行参数会被当作参数送给 ENTRYPOINT 指令指定的程序
命令格式和案例说明:
ENTRYPOINT可以和CMD一起用,一般是变参才会使用 CMD ,这里的 CMD 等于是在给 ENTRYPOINT 传参。
当指定了ENTRYPOINT后,CMD的含义就发生了变化,不再是直接运行其命令而是将CMD的内容作为参数传递给ENTRYPOINT指令,他两个组合会变成
案例如下:假设已通过 Dockerfile 构建了 nginx:test 镜像:
优点:在执行docker run的时候可以指定 ENTRYPOINT 运行所需的参数。
缺点:如果 Dockerfile 中如果存在多个 ENTRYPOINT 指令,仅最后一个生效。
2.3.14、小总结
2.4、案例
2.4.1、自定义镜像mycentosjava8
要求:
Centos7镜像具备vim+ifconfig+jdk11:
JDK的下载镜像地址
下载地址:
https://www.oracle.com/java/technologies/downloads/#java8
https://mirrors.yangxingzhen.com/jdk/
编写:准备编写Dockerfile文件,注意是大写字母D
1 | FROM centos:7 |
构建:
docker build -t 新镜像名字:TAG .
注意,上面TAG后面有个空格,有个点
运行:
docker run -it 新镜像名字:TAG
再体会下UnionFS(联合文件系统):
1 | UnionFS(联合文件系统):Union文件系统(UnionFS)是一种分层、轻量级并且高性能的文件系统,它支持对文件系统的修改作为一次提交来一层层的叠加,同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。Union 文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承,基于基础镜像(没有父镜像),可以制作各种具体的应用镜像。 |
2.4.2、虚悬镜像
是什么:仓库名、标签都是
Dockerfile写一个:
1 vim Dockerfile
1 | from ubuntu |
2 docker build .
查看:
docker image ls -f dangling=true
删除:
docker image prune
虚悬镜像已经失去存在价值,可以删除
2.4.3、自定义镜像myubuntujak11
Dockerfile:
1 | FROM ubuntu |
docker build -t myubuntujdk11:1.0 .
docker run -it myubuntujdk11:1.0
2.5、小总结
3、Docker微服务实战
3.1、通过IDEA新建一个普通微服务模块
3.1.1、建Module
docker_boot
3.1.2、改pom
1 |
|
3.1.3、写yml
server.port=6001
3.1.4、主启动
3.1.5、业务类
1 | package com.lxg.docker.controller; |
3.2、通过dockerfile发布微服务部署到docker容器
3.2.1、IDEA工具里面搞定微服务jar包
3.2.2、编写Dockerfile
1 | # 基础镜像使用java |
3.2.3、将微服务jar包和Dockerfile文件上传到同一个目录下/mydocker
3.2.4、构建镜像
docker build -t zzyy_docker:1.6 .
打包成镜像文件
3.2.5、运行容器
docker run -d -p 6001:6001 zzyy_docker:1.6
3.2.6、访问测试
4、Docker网络
4.1、是什么
docker不启动,默认网络情况:
ens33
lo
virbr0
1 | 在CentOS7的安装过程中如果有选择相关虚拟化的的服务安装系统后,启动网卡时会发现有一个以网桥连接的私网地址的virbr0网卡(virbr0网卡:它还有一个固定的默认IP地址192.168.122.1),是做虚拟机网桥的使用的,其作用是为连接其上的虚机网卡提供 NAT访问外网的功能。 |
docker启动后,网络情况:
会产生一个名为docker0的虚拟网桥
查看docker网络模式命令
默认创建3大网络模式
4.2、常用基本命令
4.2.1、All命令
4.2.2、查看网络
docker network ls
4.2.3、查看网络源数据
docker network inspect XXX网络名字
4.2.4、删除网络
docker network rm XXX网络名字
4.2.5、案例
4.3、能干嘛
容器间的互联和通信以及端口映射
容器IP变动时候可以通过服务名直接网络通信而不受到影响
4.5、网络模式
4.5.1、总体介绍
bridge模式:使用–network bridge指定,默认使用docker0
host模式:使用–network host指定
none模式:使用–network none指定
container模式:使用–network container:NAME或者容器ID指定
4.5.2、容器实例内默认网络IP生产规则
说明:
1 先启动两个ubuntu容器实例
2 docker inspect 容器ID or 容器名字
3 关闭u2实例,新建u3,查看ip变化
结论:
docker容器内部的ip是有可能会发生改变的
4.5.3、案例说明
1、bridge:
1 | Docker 服务默认会创建一个 docker0 网桥(其上有一个 docker0 内部接口),该桥接网络的名称为docker0,它在内核层连通了其他的物理或虚拟网卡,这就将所有容器和本地主机都放到同一个物理网络。Docker 默认指定了 docker0 接口 的 IP 地址和子网掩码,让主机和容器之间可以通过网桥相互通信。 |
查看 bridge 网络的详细信息,并通过 grep 获取名称项
docker network inspect bridge | grep name
ifconfig
案例:
说明:
1 | 1 Docker使用Linux桥接,在宿主机虚拟一个Docker容器网桥(docker0),Docker启动一个容器时会根据Docker网桥的网段分配给容器一个IP地址,称为Container-IP,同时Docker网桥是每个容器的默认网关。因为在同一宿主机内的容器都接入同一个网桥,这样容器之间就能够通过容器的Container-IP直接通信。 |
代码:
1 | docker run -d -p 8081:8080 --name tomcat81 billygoo/tomcat8-jdk8 |
两两匹配验证:
2、host
是什么:
直接使用宿主机的 IP 地址与外界进行通信,不再需要额外进行NAT 转换。
案例:
说明:容器将不会获得一个独立的Network Namespace, 而是和宿主机共用一个Network Namespace。容器将不会虚拟出自己的网卡而是使用宿主机的IP和端口。
代码:
警告:
docker run -d -p 8083:8080 –network host –name tomcat83 billygoo/tomcat8-jdk8
1 | 问题: |
正确:
docker run -d –network host –name tomcat83 billygoo/tomcat8-jdk8
无之前的配对显示了,看容器实例内部
docker run -d –network host –name tomcat83 billygoo/tomcat8-jdk8
没有设置-p的端口映射了,如何访问启动的tomcat83??
1 | http://宿主机IP:8080/ |
3、none
是什么:
在none模式下,并不为Docker容器进行任何网络配置。
也就是说,这个Docker容器没有网卡、IP、路由等信息,只有一个lo
需要我们自己为Docker容器添加网卡、配置IP等。
禁用网络功能,只有lo标识(就是127.0.0.1表示本地回环)
案例:
docker run -d -p 8084:8080 –network none –name tomcat84 billygoo/tomcat8-jdk8
进入容器内部查看
在容器外部查看
4、container
是什么:
container⽹络模式
新建的容器和已经存在的一个容器共享一个网络ip配置而不是和宿主机共享。新创建的容器不会创建自己的网卡,配置自己的IP,而是和一个指定的容器共享IP、端口范围等。同样,两个容器除了网络方面,其他的如文件系统、进程列表等还是隔离的。
错误案例:
docker run -d -p 8085:8080 –name tomcat85 billygoo/tomcat8-jdk8
docker run -d -p 8086:8080 –network container:tomcat85 –name tomcat86 billygoo/tomcat8-jdk8
运行结果:
1 | # 相当于tomcat86和tomcat85公用同一个ip同一个端口,导致端口冲突 |
正确案例:
Alpine操作系统是一个面向安全的轻型 Linux发行版
1 | Alpine Linux 是一款独立的、非商业的通用 Linux 发行版,专为追求安全性、简单性和资源效率的用户而设计。 可能很多人没听说过这个 Linux 发行版本,但是经常用 Docker 的朋友可能都用过,因为他小,简单,安全而著称,所以作为基础镜像是非常好的一个选择,可谓是麻雀虽小但五脏俱全,镜像非常小巧,不到 6M的大小,所以特别适合容器打包。 |
docker run -it –name alpine1 alpine /bin/sh
docker run -it –network container:alpine1 –name alpine2 alpine /bin/sh
运行结果,验证共用搭桥:
假如此时关闭alpine1,再看看alpine2
5、自定义网络
过时的link:
案例:
1、before:
案例
1 | docker run -d -p 8081:8080 --name tomcat81 billygoo/tomcat8-jdk8 |
上述成功启动并用docker exec进入各自容器实例内部
问题:
按照IP地址ping是OK的
按照服务名ping结果???
2、after:
案例
自定义桥接网络,自定义网络默认使用的是桥接网络bridge
新建自定义网络
新建容器加入上一步新建的自定义网络
docker run -d -p 8081:8080 –network zzyy_network –name tomcat81 billygoo/tomcat8-jdk8
docker run -d -p 8082:8080 –network zzyy_network –name tomcat82 billygoo/tomcat8-jdk8
互相ping测试
问题结论:
自定义网络本身就维护好了主机名和ip的对应关系(ip和域名都能通)
自定义网络本身就维护好了主机名和ip的对应关系(ip和域名都能通)
自定义网络本身就维护好了主机名和ip的对应关系(ip和域名都能通)
4.6、Docker平台架构图解
4.6.1、整体说明
从其架构和运行流程来看,Docker 是一个 C/S 模式的架构,后端是一个松耦合架构,众多模块各司其职。
Docker 运行的基本流程为:
1 用户是使用 Docker Client 与 Docker Daemon 建立通信,并发送请求给后者。
2 Docker Daemon 作为 Docker 架构中的主体部分,首先提供 Docker Server 的功能使其可以接受 Docker Client 的请求。
3 Docker Engine 执行 Docker 内部的一系列工作,每一项工作都是以一个 Job 的形式的存在。
4 Job 的运行过程中,当需要容器镜像时,则从 Docker Registry 中下载镜像,并通过镜像管理驱动 Graph driver将下载镜像以Graph的形式存储。
5 当需要为 Docker 创建网络环境时,通过网络管理驱动 Network driver 创建并配置 Docker 容器网络环境。
6 当需要限制 Docker 容器运行资源或执行用户指令等操作时,则通过 Execdriver 来完成。
7 Libcontainer是一项独立的容器管理包,Network driver以及Exec driver都是通过Libcontainer来实现具体对容器进行的操作。
4.6.2、整体架构
5、Docker-compose容器编排
5.1、是什么
Compose 是 Docker 公司推出的一个工具软件,可以管理多个 Docker 容器组成一个应用。你需要定义一个 YAML 格式的配置文件docker-compose.yml,写好多个容器之间的调用关系。然后,只要一个命令,就能同时启动/关闭这些容器
Docker-Compose是Docker官方的开源项目,
负责实现对Docker容器集群的快速编排。
5.2、能干嘛
docker建议我们每一个容器中只运行一个服务,因为docker容器本身占用资源极少,所以最好是将每个服务单独的分割开来但是这样我们又面临了一个问题?
如果我需要同时部署好多个服务,难道要每个服务单独写Dockerfile然后在构建镜像,构建容器,这样累都累死了,所以docker官方给我们提供了docker-compose多服务部署的工具
例如要实现一个Web微服务项目,除了Web服务容器本身,往往还需要再加上后端的数据库mysql服务容器,redis服务器,注册中心eureka,甚至还包括负载均衡容器等等。
Compose允许用户通过一个单独的docker-compose.yml模板文件(YAML 格式)来定义一组相关联的应用容器为一个项目(project)。
可以很容易地用一个配置文件定义一个多容器的应用,然后使用一条指令安装这个应用的所有依赖,完成构建。Docker-Compose 解决了容器与容器之间如何管理编排的问题。
5.3、去哪下
官网:https://docs.docker.com/compose/compose-file/compose-file-v3/
官网下载:https://docs.docker.com/compose/install/
安装步骤:
curl -L “https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)” -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose
docker-compose –version
新版的已经自带了,命令:docker compose version可以查看
卸载步骤:
5.4、Compose核心概念
一文件:docker-compose.yml
两要素:
服务(service)
一个个应用容器实例,比如订单微服务、库存微服务、mysql容器、nginx容器或者redis容器
工程(project)
由一组关联的应用容器组成的一个完整业务单元,在 docker-compose.yml 文件中定义。
5.5、Compose使用的三个步骤
编写Dockerfile定义各个微服务应用并构建出对应的镜像文件
使用 docker-compose.yml 定义一个完整业务单元,安排好整体应用中的各个容器服务。
最后,执行docker-compose up命令 来启动并运行整个应用程序,完成一键部署上线
5.6、Compose常用命令
1 | Compose常用命令 |
5.7、Compose编排微服务
5.7.1、改造升级微服务工程docker_boot
以前的基础版:
sql建表:
1 |
|
一键生成实体类mapper、service等
改pom:
1 |
|
注意springboot版本可能会与swagger冲突
编写配置文件:
1 | server.port=6001 |
主启动类:
1 | package com.lxg.docker; |
业务类:
config配置类:
RedisConfig:
1 | package com.lxg.docker.config; |
SwaggerConfig:
1 | package com.lxg.docker.config; |
新建entity:
1 | package com.lxg.docker.domain; |
Userservice:
1 | package com.lxg.docker.service; |
UserServiceImpl:
1 | package com.lxg.docker.service.impl; |
UserController:
1 | package com.lxg.docker.controller; |
mvn package命令将微服务形成新的jar包
并上传到Linux服务器/mydocker目录下
编写Dockerfile
1 | # 基础镜像使用java |
构建镜像:docker build -t xiaolin_docker:3.0 .
5.7.2、不用Compose
单独的mysql容器实例
新建mysql容器实例
docker run -p 3306:3306 –name mysql57 –privileged=true -v /zzyyuse/mysql/conf:/etc/mysql/conf.d -v /zzyyuse/mysql/logs:/logs -v /zzyyuse/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7
进入mysql容器实例并新建库db2021+新建表t_user
1 | docker exec -it mysql57 /bin/bash |
单独的redis容器实例
docker run -p 6379:6379 –name redis608 –privileged=true -v /app/redis/redis.conf:/etc/redis/redis.conf -v /app/redis/data:/data -d redis:6.0.8 redis-server /etc/redis/redis.conf
微服务工程
docker run -d -p 6001:6001 xiaolin_docker:3.0
上面三个容器实例依次顺序启动成功
5.7.3、swagger测试
http://8.130.115.225:6001/swagger-ui.html#
5.7.4、问题
先后顺序要求固定,先mysql+redis才能微服务访问成功
多个run命令……
容器间的启停或宕机,有可能导致IP地址对应的容器实例变化,映射出错,
要么生产IP写死(可以但是不推荐),要么通过服务调用
5.7.5、使用Compose
服务编排,一套带走,安排
编写docker-compose.yml文件:
1 | version: "3" |
第二次修改微服务工程docker_boot:
执行 docker-compose up
或者
执行 docker-compose up -d
新版本命令:docker compose up -d
进入mysql容器实例并新建库db2021+新建表t_user
1 |
|
测试通过
Compose常用命令
1 | Compose常用命令 |
关停
6、Docker轻量级可视化工具Portainer
6.1、是什么
Portainer 是一款轻量级的应用,它提供了图形化界面,用于方便地管理Docker环境,包括单机环境和集群环境。
6.2、安装
6.2.1、官网
Install Portainer CE with Docker on Linux - Portainer Documentation
6.2.2、步骤
docker命令安装:
1 | 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 |
新版本:
1 | docker volume create portainer_data |
–restart=always 即类似开机自启动,docker启动或者重新启动就会跟着启动
第一次登录需创建admin,访问地址:ip:9000 或https://ip:9443
设置admin用户和密码后首次登陆
选择local选项卡后本地docker详细信息展示
上一步的图形展示,能想得起对应命令吗?
7、Docker容器监控之CAdvisor+InfluxDB+Granfana
7.1、原生命令
docker stats命令的结果
通过docker stats命令可以很方便的看到当前宿主机上所有容器的CPU,内存以及网络流量等数据,一般小公司够用了。。。。
但是,
docker stats统计结果只能是当前宿主机的全部容器,数据资料是实时的,没有地方存储、没有健康指标过线预警等功能
7.2、是什么
容器监控3剑客:
一句话
CAdvisor监控收集+InfluxDB存储数据+Granfana展示图表
CAdvisor
InfluxDB
Granfana
总结
7.3、compose容器编排,一套带走
新建目录
新建3件套组合的
docker-compose.yml:
1 | version: '3.1' |
启动docker-compose文件:
docker compose up
查看三个服务容器是否启动:
测试:
浏览cAdvisor收集服务,http://ip:8080/
第一次访问慢,请稍等
cadvisor也有基础的图形展现功能,这里主要用它来作数据采集
浏览influxdb存储服务,http://ip:8083/
浏览grafana展现服务,http://ip:3000
ip+3000端口的方式访问,默认帐户密码(admin/admin)
配置步骤:
配置数据源
选择influxdb数据源
配置细节
配置面板panel
到这里cAdvisor+InfluxDB+Grafana容器监控系统就部署完成了
8、最终总结
进阶篇:k8s