首页 思维导图 详情

Docker

2023-09-06 19:36:43 0 举报
AI智能生成
docker知识学习
docker
作者其他创作
大纲/内容
Docker 基础篇
Docker基础
Docker基本组成
镜像
容器
1.从面向对象角度
Docker利用容器〈Container)独立运行的一个或一组应用，应用程序或服务运行在容器里面，容器就类似于一个虚拟化的运行环境，容器是用镜像创建的运行实例。就像是Java中的类和实例对象一样，镜像是静态的定义，容器是镜像运行时的实体。容器为镜像提供了一个标准的和隔离的运行环境，它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台
2从镜像容器角度
可以把容器看做是一个简易版的Linux环境(包括root用户权限、进程空间、用户空间和网络空间等）和运行在其中的应用程序。
仓库
仓库（Repository）是集中存放镜像文件的场所。类似于Maven仓库，存放各种jar包的地方;github仓库，存放各种git项目的地方;
Docker公司提供的官方registry被称为Docker Hub，存放各种镜像模板的地方。
仓库分为公开仓库（Public）和私有仓库（Private）两种形式。
最大的公开仓库是Docker Hub(https://hub.docker.com/)，
存放了数量庞大的镜像供用户下载。国内的公开仓库包括阿里云、网易云等
为什么使用docker
1.系统平滑移植,容器虚拟化技术
2.. 可以把原始环境一模一样的复制过来,开发人员利用Docker可以消除协作编码时
"在我的机器上可以正常工作"的问题
3. Docker 的出现使得Docker 打破过去程序即应用的观念, 透过镜像将作业系统核心除外,运作应用程式所需要的系统环境,
由上而下打包,达到应用程式跨平台间的无缝接轨运作.
总结:   解决了运行环境和配置问题的软件容器,方便做持续集成并有助于整体发布的容器虚拟化技术,
说白了就是复制原来环境,避免出现不同环境之间的差异问题
docker理念
子主题
docker简介
虚拟机和容器区别
虚拟机就是带环境安装的一种解决方案
它可以在一种操作系统里面运行另一种操作系统，比如在window10 系统里运行Linux
系统CentOS7 ，应用程序对此毫无感知，因为虚拟机看上去跟真实系统一模一样，而对于底层系统
来说，虚拟机就是一个普通文件，不需要了就删掉，对其他部门毫无影响，这类虚拟机完美的运行了
另一套系统，能够使应用程序，操作系统和硬件之间的逻辑不变
能干嘛
一次构建，随处运行
1. 更快速的应用交付和部署
传统的应用开发完成后，需要一堆安装程序和配置说明文档，安装部署后需根据配置文档进行
繁杂的配置才能正常运行，
Docker化之后只需要交付少量容器镜像文件，在正式生产环境加载镜像并运行即可，应用安装配置
在镜像里已经内置好，大大节省部署配置和测试验证时间。
2. 更便捷的升级和扩缩容
随着微服务架构和Docker的发展，大量的应用会通过微服务方式架构，应用的开发构建将
变成搭乐高积木一样， 每个Docker容器将变成一块“积木”，应用的升级将变得非常容易
。当现有的容器不足以支撑业务处理时，可通过镜像运行新的容器进行快速扩容，使应用
系统的扩容从原先的天升级变成分钟甚至秒级
3. 更简单的系统运维
应用容器化运行后，生产环境运行的应用可与开发，测试环境的应用高度一致，容器会将应用程序相关
的环境和状态完全封装起来，不会因为底层基础架构和操作系统的不一致性给应用带来影响，产生新的BUG，
当出现程序异常时，也可以通过测试环境的相同容器进行快速定位和修复。
4. 更高效的计算资源利用
Docker 是内核级虚拟化， 其不像传统的虚拟化技术一样需要额外的Hyperisor支持，所以在一台物理机上
可以运行多个容器实例。可大大提升物理服务器的CPU和内存的利用率。
docker优势
Docker  容器是在操作系统层面上实现虚拟化，直接复用本地主机的操作系统，
而传统虚拟机则是在硬件层面实现虚拟化，与传统的虚拟机相比，Docker优势体现为启动速度快，占用体积小
docker和虚拟机区别
1. 传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上在运行所需应用进程
2. 容器内的应用进程直接运行与宿主的内核， 容器内没有自己的内核且也没有进行硬件虚拟，因此
容器要比传统虚拟机更为轻便
3. 每个容器之间相互隔离， 每个容器由自己的文件系统， 容器之间进程不会相互影响
Docker实操
1. Docker 安装
2. 安装条件
3. Docker 三要素
1. 镜像
概念
2. 容器
概念
3. 仓库
概念
4. 优势
子主题
5. 总结
1. 需要正确的理解仓库、镜像、容器这几个概念
Docker本身是一个容器运行载体或称之为管理引擎。我们
把应用程序和配置依赖打包好形成一个可交付的运行环境，这个打包好的运行环境
就是一个image镜像文件。只有通过这个镜像文件才能生成Docker容器实例（类似java
中new出来的一个对象）。
image文件可以看作是容器的模板。Docker根据image文件生成容器实例。同一个image文件，可以生成
多个同时运行的容器实例。
2. 镜像文件
image 文件生成的容器实例，本身也是一个文件，称为镜像文件
3. 容器实例
一个容器运行一种服务，当我们需要的时候，就可以通过docker客户端创建一个对应的运行实例，也就是我们的容器
4. 仓库
就是放一堆镜像的地方，我们可以把镜像发布到仓库中，需要的时候子啊从仓库中拉下来就可以了。
4.  平台架构图解（简约版）
简图
5.  docker 工作原理
Docker 是一个Client-Server结构的系统，Docker守护进程运行在主机上，然后通过Socket
连接从客户端访问，守护进程从客户端接受命令运行子啊主机上的容器。容器，是一个运行时环境
就是我们前面说到的集装箱。可以对比mysql 演示对比讲解
Docker原理
Docker是一个 C/S 模式的架构，后端是一个松耦合架构，众多模块各司其职。Docker 运行的基本流程为:
1. 用户是使用 Docker Client与 Docker Daemon 建立通信，并发送请求给后者。
2.  Docker Daemon 作为 Docker 架构中的主体部分，首先提供 Docker Server 的功能使其可以接受 Docker Cient 的请求，
3.  Docker Engine 执行 Docker内部的一系列工作，每一项工作都是以一个 Job 的形式的存在。
4. Job 的运行过程中，当需要容器镜像时，则从 Docker Reisty 中下载镜像，并通过镜像管理驱动 Graph driver将下载像以Graph的形式存储.
5. 当需要为 Docker创建网络环境时，通过网络管理驱动 Network driver 创建并配置 Docker 容器网络环境。
6. 当需要限制 Docker容器运行资源或执行用户指令等操作时，则通过 Exec driver 来完成。
7. Libcontainer是一项独立的容器管理包，Network driver以及Exec driver都是通过Libcontainer来实现具体对容器进行的操作
Docker安装
1.  确定你是CentOS7 及以上版本
cat/etc/redhat-release
2. 卸载旧版本
子主题
3. yum 安装gcc相关
4. 安装需要的软件包
5. 设置stable镜像仓库
6. 更新yum软件包索引
7. 安装Docker CE
8. 启动Docker
9. 测试
Docker
docker  run 干了什么
比虚拟机快的原因
Docker 常用命令
1. 帮助启动类命令
1. 启动docker:   systemctl  start   docker
2.停止docker:  systemctl  stop  docker
3. 重启docker:   systemctl  restart   docker
4. 查看docker状态:  systemctl  status  docker
5. 开机启动:  systemctl  enable  docker
6. 查看docker 概要 信息:  docker  info
7. 查看docker 总体帮助文档:  docker --help
8. 查看docker 命令帮助文档: docker 具体命令 --help
2. 镜像命令
1. docker   images
列出本地主机的镜像
子主题
OPTIONS说明
-a :  列出本地所有的镜像(含历史映像层)
-q : 只显示镜像ID
2.  docker  search 某个镜像的名字
1. 网站
https://hub.docker.com
2. 命令 
docker  search [OPTIONS]  镜像名字
案例
OPTIONS 说明:
--limit :  只列出N个镜像, 默认25个
docker  search --limit 5  redis
3.  docker  pull 某个xxx镜像名字
1.  下载镜像
2. docker  pull  镜像名字[:TAG]
3. docker pull  镜像名字
没有TAG 就是最新版
等价于
docker  pull  镜像名字 :  latest
docker  pull  ubuntu
4.  docker  system  df  查看镜像/容器/数据卷所占的空间
5.  docker  rmi  某个xxx镜像名字ID
1. 删除镜像
2. 删除单个
docker  rmi -f  镜像ID
3. 删除多个
docker  rmi  -f  镜像名1:TAG  镜像名2:TAG
4. 删除全部
docker   rmi -f  $(docker  images -qa)
6. 面试题:  谈谈docker 虚悬镜像是什么? 
是什么
仓库名,标签都是<none> 的镜像,俗称虚悬镜像dangling  image
长什么样
后续Dockerfile 章节在介绍
7.  思考
3. 容器命令
有镜像才能创建容器, 这是根本前提(下载一个CentOS或者ubuntu镜像演示)
说明
docker   pull  centos
docker  pull  ubuntu
本次演示用ubuntu演示
新建+启动容器
docker  run[OPTIONS] IMAGE[COMMAND][ARG...]
OPTIONS说明
启动交互式容器(前台命令行)
列出当前所有正在运行的容器
docker  ps[OPTIONS]
OPTIONS说明
退出容器
有两种退出方式
exit
run 进去容器,exit 退出,容器停止
ctrl+p+q
run进去容器, ctrl+p+q退出, 容器不停止
启动已停止运行的容器
docker  start  容器ID或者容器名
重启容器
docker  restart  容器ID或者容器名
停止容器
docker  stop  容器ID或者容器名
强制停止容器
docker  kill 容器ID或者容器名
删除已停止的容器
docker  rm  容器ID(只能删除已停止的容器))
一次性删除多个容器实例
docker  rm  -f  $(docker  ps  -a -q)
docker  ps  -a  -q  |  xargs  docker  rm
重要
1. 有镜像才能创建容器, 这是根本前提(下载一个Redis6.0.8 镜像演示)
子主题
2. 启动守护式容器(后台服务器)
1.  大部分的场景下, 我们希望docker的服务是在后台运行的,我们可以通过 -d 指定容器的后台运行模式
2. docker  run  -d  容器名
3. redis  前后台启动演示case
1. 前台交互式启动
docker  run  -it  redis:6.0.8
2. 后台守护式启动
docker  run  -d  redis:6.0.8
3. 查看容器日志
docker  logs  容器ID
4.  查看容器内运行的进程
5. 查看容器内内部细节
docker  inspect  容器ID
6. 进入正在运行的容器并以命令行交互
1. docker  exec -it  容器ID  bashShell
子主题
2. 重新进入docker   attach  容器ID
3. 按理演示, 用centos 或者ubuntu  都可以
4. 上述两个区别
1. attach  直接进入容器启动命令的终端, 不会启动新的进程
用exit 退出, 会导致容器的停止.
子主题
2.  exec  是在容器中打开新的终端,并且可以启动新的进程
用exit  退出,不会导致容器的停止.
5. 推荐大家使用docker  exec命令,  因为退出容器终端,不会导致容器的停止
6. 用之前的redis  容器实例进入试试
7. 从容器内拷贝文件到主机上
容器->  主机
docker  cp  容器ID: 容器内路径  目的主机路径
8. 导入和导出容器
1. export  导出容器的内容流作为一个tar文档文件[对应import命令]
2. import  从tar 包中的内容创建一个新的文件系统在导入为镜像[对应export]
3. 案例
docker export 容器ID > 文件名.tar
cat  文件名.tar   |  docker  import   -   镜像用户/镜像名: 镜像版本号
4. 小总结
命令
命令解释
命令解释
Docker镜像
1. 是什么
是什么
镜像:   是一种轻量级,可执行的独立软件包,它包含运行某个所需的所有内容,我们把应用程序和配置依赖打包好形成一个可交付的
运行环境(包括代码,运行时需要的库,环境变量和配置文件等), 这个打包好的运行环境就是image镜像文件.

只有通过这个镜像文件才能生成Docker容器实例(类似Java 中new  出来一个对象).
分层的镜像
子主题
UnionFS(联合文件系统)
UnionFS(联合文件系统):  Union 文件系统(UnionFS)  是一种分层,轻量级并且高性能的文件系统,它支持对文件系统的修改作为一次提交
来一层层的叠加,同时可以将不同目录挂载到同一个虚拟文件系统下,Union文件系统是Docker镜像的基础,镜像可以通过分层来进行继承.基于
基础镜像(没有父镜像), 可以制作各种具体的应用镜像.

特性:  一次同时加在多个文件系统,但从外面看起来,只能看到一个文件系统,  联合加载会把各层文件系统叠加起来,这样最终的文件
系统会包含所有底层的文件和目录
Docker镜像加载原理
Docker镜像加在原理:
   docker 的镜像实际上由一层一层的文件系统组成,这种层级的文件系统UnionFS.
bootfs(boot file  system) 主要包含bootloader 和kernel,  bootloader 主要是引导加载kernel.Linux刚启动时会加载bootfs
文件系统,在Docker镜像的最底层是引导文件系统bootfs, 这一层与我们典型的linux/Unix系统是一样的,包含boot加载器和内核.
当boot 加载完成之后整个内核就都在内存中,此时内存的使用权已由bootfs转交给内核,此时系统也会卸载bootfs.

在rootfs 之上, 包含的就是典型Linux系统的/dev, /proc, /bin, /etc 等标准目录和文件.  rootfs就是各种不同的操作系统发行版,
比如Ubuntu,CentOS等等.
为什么Docker镜像要采用这种分层结构呢
镜像分层最大的一个好处就是共享资源, 方便复制迁移,就是为了复用.

比如说有多个镜像都从相同的base镜像构建而来,那么Docker Host 只需在磁盘上保存一份base镜像;
同时内存中也需加载一份base镜像,就可以为所有容器服务了, 而且镜像的每一层都可以被共享.
2. 重点理解
Docker 镜像层都是只读的,容器层是可写的
当容器启动时,一个新的可写层被加载到镜像的顶部.
这一层通常被称作"容器层","容器层"之下的都叫"镜像层"
3. Docker 镜像commit操作案例
docker  commit  提交容器副本使之成为一个新的镜像
docker  commit -m="提交的描述信息"-a="作者"容器ID要创建的目标镜像名:[标签名]
案例演示ubuntu安装vim
从Hub上下载ubuntu镜像到本地并成功运行
原始的默认Ubuntu镜像是不带着vim命令的
外网连通的情况下,安装vim
安装完成后,commit 我们自己的新镜像
启动我们的新镜像并和原来的对比
小总结
本地镜像发布到阿里云
本地镜像发布到私有库
本地镜像发布到私有库流程
是什么
将本地镜像推送到私有库
1. 下载镜像Docker Registry
docker  pull  Registry
2. 运行私有库Registry,相当于本地有个私有Docker Hub
3. 案例演示创建一个新镜像,ubuntu安装ifconfig命令
4. curl  验证私服库上有什么镜像
5. 将新镜像zzyyubuntu:1.2 修改符合私服规范的Tag
6. 修改配置文件使之支持http
7. push  推送到私服库
8.  curl  验证私服库上有什么镜像
7. Docker  容器数据卷
1. 坑:  容器卷记得加入
--priviledged=true
why
2. 回顾下上一讲的知识点,参数V
3. 是什么
1. 一句话:  有点类似我们Redis里面的rdb 和aof 文件
2.  将docker 容器内的数据保存进宿主机的磁盘中
3. 运行一个带有容器卷存储功能的容器实例
docker  run  -it  --privileged=true -v  /宿主机绝对路径目录:/容器内目录    镜像名
4. 能干嘛
将运用于运行环境打包镜像,run 后形成容器实例运行, 但是我们对数据的要求希望是持久化的
Docker  容器产生的数据,如果不备份,那么当容器实例删除后,容器内的数据自然也就没有了.
为了能保存数据在docker中我们使用卷.
特点: 
1. 数据卷可在容器之间共享或重用数据
2. 卷中的更改可以直接实时生效
3. 数据卷中的更改不会包含在镜像的更新中
4. 数据卷的生命周期一直持续到没有容器使用它为止
作用:  保证数据库数据不会丢失
5.数据卷案例
1. 宿主vs 容器之间映射添加容器卷
直接命令添加
1. 命令
docker run -it  --privileged=true  -v  /宿主机绝对路径目录:/容器内目录   镜像名
2. 查看数据卷是否挂载成功
3. 容器和宿主机之间数据共享
2.  读写规则映射添加说明
1. 读写(默认)
docker  run  --privileged=true  -v  /宿主机绝对路径目录:/容器内目录:rw    镜像名
默认同上案例,  默认就是rw
2. 只读
容器实例内部被限制, 只能 读取不能写
docker  run  -it  --privileged=true  -v  /宿主机绝对路径目录:/容器内目录:ro    镜像名
3. 卷的继承和共享
1. 宿主机vs 容器之间映射添加容器卷
2.  读写规则映射说明
3. 卷的继承和共享
1. 容器1 完成和宿主机的映射
2. 容器2 继承容器1 的卷规则
docker  run  -it  --privileged=true  --volumes-from  父类  --name u2  ubuntu
8. Docker 常规安装简介
1.  总体步骤
1. 搜索镜像
2.  拉取镜像
3. 查看镜像
4. 启动镜像
服务端口映射
5. 停止镜像
6. 移除镜像
2.  安装tomcat
1. docker  hub 上面查找tomcat镜像
2. 从docker hub 上拉取tomcat  镜像到本地
3. docker  images  查看是否有拉取到的tomcat
4. 使用tomcat镜像创建容器实例(也叫运行镜像)
docker  run  -it  -p  8080:8080  tomcat
-p  小写, 主机端口: docker 容器端口
-P 大写,  随机分配端口
i: 交互
t:  终端
d: 后台
5. 访问猫首页
问题
解决
1. 可能没有映射端口或者没有关闭防火墙
子主题
2. 把webapps.dist 目录换成webapps
先成功启动tomcat
查看wenapps文件是否为空
6. 免修改版说明
docker  pull  billygoo/tomcat8-jdk8
docker  run -d -p 8080:8080  --name  mytomcat8 billygoo/tomcat8-jdk8
3.  安装mysql
1. docker  hub  上面查找mysql镜像
2. 从docker hub 上(阿里云加速器) 拉取mysql镜像到本地标签为5.7
3. 使用mysql5.7  镜像创建容器(也叫运行镜像)
1.  命令出处,哪里来的?
2. 简单版
1. 使用mysql 镜像
子主题
2. 建库建表插入数据
3. 外部win10  也来连接运行在docker上的mysql 容器实例服务
4. 问题
1. 插入中文数据试试
为什么报错?
docker 上默认字符集编码隐患
2. 删除容器后, 里面的mysql 数据怎么办
从删库到跑路?
3. 实战版
1. 新建mysql  容器实例
子主题
docker run -p 3306:3306 \
           --name mysql \
           --privileged=true \
           -v /app/mysql-master/log:/var/log/mysql \
           -v /app/mysql-master/data:/var/lib/mysql \
           -v /app/mysql-master/conf:/etc/mysql \
           -e MYSQL_ROOT_PASSWORD=root \
           -d mysql:5.7
2. 新建my.conf
通过容器卷同步给mysql容器实例
3. 重新启动mysql  容器实例再重新进入并查看字符编码
4. 在新建库新建表在插入中文试试
5. 结论
子主题
6. 假如将当前容器实例删除,在重来一次,之前的db01实例
注意
my.cnf  文件的配置是粘贴过来的,,不是手动加的,不然docker 里的mysql  无法重启
配置
[client]
default_character_set=utf8
[mysqld]
collation_server = utf8_general_ci
character_set_server = utf8
4.  安装redis
1. 从docker  hub  上(阿里云加速器)  拉取redis  镜像到本地标签为6.0.8
2.  入门命令
3.  命令提醒
容器卷记得加入  --privileged=true
4.  在CentOS  宿主机下新建目录 /app/redis
mkdir  -p  /app/redis
5.  将一个redis.conf  文件模板 拷贝进/app/redis 目录下
子主题
6. /app/redis  目录下修改 redis.conf  文件
默认出厂的原始redis.conf
7.  使用redis6.0.8  镜像创建容器(也叫运行容器)
docker run -d -p 6379:6379 --name redis --privileged=true \
           -v /app/redis/redis.conf:/etc/redis/redis.conf \
           -v /app/redis/data:/data \
           redis:6.0.8 \
           redis-server /etc/redis/redis.conf
8.  测试redis-cli  连接上来
docker exec -it redis /bin/bash
9.  请证明docker  启动使用了我们指定的配置文件
10 . 测试redis-cli  连接上来第二次
注意
1.  第7 步,里的命令是从其他地方来的,,视频里的启动不了
2.  这里有两个不错的文档地址,可以参考
https://www.yuque.com/tmfl/cloud/ixlgsl#37807d42
https://www.yuque.com/li.xx/open/elw9tu#HbBbm
5.  安装nginx
见高级篇Portainer
Docker 高级篇
1. Docker 复杂安装详说
1.  安装mysql  主从复制
1. 主从复制原理
默认你懂
2.  主从搭建步骤
1.  新建主服务器容器实例3307
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
2.   进入/mydata/mysql-master/conf 目录下新建my.cnf
vim  my.cnf
3.  修改完配置后重启master 实例
docker  restart   mysql-master
4.  进入 mysql-master  容器
1.  docker  exec  -it  mysql -master  /bin/bash
2. mysql -uroot  -proot
5. master  容器实例内创建数据同步用户
CREATE USER 'slave'@'%' IDENTIFIED BY '123456';
GRANT REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'slave'@'%';
6.  新建从服务器实例3308
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
7.  进入/mydata/mysql-slave/conf  目录下新建my.cnf
8. 修改完配置后重启slave 实例
docker restart mysql-slave
9.  在主数据库中查看主从同步状态
show  master status;
10.  进入mysql-slave  容器
1. docker  exec  -it  mysql-slave  /bin/bash
2.  mysql -uroot  -proot
11.  在从数据库中配置主从复制
change master to master_host='192.168.107.25', master_user='slave', master_password='123456', 
master_port=3307, master_log_file='mall-mysql-bin.000002', master_log_pos=774, master_connect_retry=30;
主从复制参数说明
master_host：主数据库的IP地址；
master_port：主数据库的运行端口；
master_user：在主数据库创建的用于同步数据的用户账号；
master_password：在主数据库创建的用于同步数据的用户密码；
master_log_file：指定从数据库要复制数据的日志文件，通过查看主数据的状态，获取File参数；
master_log_pos：指定从数据库从哪个位置开始复制数据，通过查看主数据的状态，获取Position参数；
master_connect_retry：连接失败重试的时间间隔，单位为秒。
注意
这里有两个细节要注意下:
1. 使用change 里的一串命令时,  master_log_file 和master_log_pos  需要和主库的保持一致
2. show  master  status ;  在主库里执行这个命令可以查看对应的配置信息
12.  在从数据库中查看主从同步状态
show slave status \G;
13. 在从数据库中开启主从同步
start  slave;
14. 查看从数据库状态发现已经同步
主库建库建表
15.  主从复制测试
从库使用主库建的表,进行查询,能查到说明,主从同步ok;
2.  安装redis 集群(大厂面试题第4季- 分布式存储案例真题)
cluster(集群) 模式-docker版哈希槽分区进行亿级数据存储
面试题
1-2亿条数据需要缓存,请问如何设计这个存储案例
回答
单机单台100%不可能,肯定是分布式存储,用redis如何落地?
上述问题阿里P6-P7工程案例和场景设计类必考题目,一般业界有3中解决方案
哈希取余分区
优点
缺点
一致性哈希算法分区
1. 是什么
一致性Hash 算法背景
       一致性哈希算法在1997年由麻省理工学院提出的,设计目标是为了解决分布式缓存数据变动
和映射问题,某个机器宕机了,分母数量改变了,自然取余数不对了.
2. 能干嘛
提出一致性Hash解决方案.
目的是当服务器个数发生变动时,尽量减少影响客户端到服务器的映射关系
3. 3大步骤
1. 算法构建一致性哈希环
2. 服务器IP节点映射
3. key  落到服务器的落键规则
4.   优点
1.  一致性哈希算法的容错性
2.  一致性哈希算法的扩展性
5. 缺点
一致性哈希算法的数据倾斜问题
子主题
6.  小总结
1.  为了在节点数目发生改变时尽可能少的迁移数据
将所有的存储节点排列在收尾相接的Hash环上每个key在计算Hash后会顺时针找到临近的存储节点存放,
而当有节点加入或退出时仅影响该节点在Hash环上顺时针相邻的后续节点.
优点
加入和删除节点只影响哈希环顺时针方向的相邻的节点,对其他节点无影响
缺点
数据的分布和节点的位置有关,因为 这些节点不是均匀的分布在哈希环上的,  所以在进行存储时达不到均匀分布的效果.
哈希槽分区
1. 是什么
1. 为什么出现
一致性哈希算法的数据倾斜问题
哈希槽实质就是一个数组,数组[0,2^14-1] 形成hash  slot空间
2. 能干嘛
解决均分分配的问题, 在数据和节点之间又加入了一层,把这层成为哈希槽(slot), 用于管理数据和节点之间的关系,
现在就相当于节点上放的是槽,槽里放的是数据.
槽解决的是粒度问题,相当于把粒度变大, 这样便于数据移动.
3. 多少个hash 槽
一个集群只能又16384 个槽,编号0-16384(0-2^14-1).  这些槽会分配集群中所有主节点,分配策略没有要求.
可以指定哪些编号的槽分配给哪个主节点. 集群会记录节点的对应关系. 解决了节点和槽的关系后,接下来就需要对key
就落入对应的槽里. slot=CRC16(key)% 16384. 以槽为单位移动数据,  因为槽的数目是固定的,处理起来比价容易,
这样数据移动问题就解决了.
2. 哈希槽计算

3主3从redis 集群扩缩容配置案例架构说明
开打步骤
3主3从redis 集群配置
1. 关闭防火墙+ 启动docker 后台服务
systemctl   start docker
2. 新建6个docker 容器实例
命令分步解释
1.  docker  run
创建并运行docker容器实例
2.  --name  redis-node-6
容器名字
3.  --net  host
使用宿主机的IP和端口,默认
4.  --privileged=true
获取宿主机root用户权限
5. -v   /data/redis/share/redis-node-6:/data
容器卷,宿主机地址:docker 内部地址
6.  redis:6.0.8
redis 镜像和版本号
7.  --cluster-enabled  yes
开启redis集群
8.  --appendonly   yes
开启持久化
9. --port  6386
redis  端口号
3. 进入容器redis-node-1 并为6台机器构建集群关系
1.  进入容器
docker  exec  -it   redis-node-1  /bin/bash
2.  构建主从关系
截图中的ip是linxu 的ip
3.  一切OK的话,3主3从搞定
3主3从
4. 链接进入6581 作为切入点,  查看集群状态
1.  链接进入6381  作为切入点, 查看节点状态
2.  cluster   info
子主题
3.  cluster   nodes
可以用来查看从节点挂在哪个主节点下面
主从容错切换迁移案例
数据读写存储
1.  启动6机 构成的集群并通过exec进入
2. 对6381  新增两个key
3. 防止路由失效加参数-c  并新增两个key
4.  查看集群信息
容错切换迁移
1.  主6381  和 从机切换,先停止主机6381
2. 再次查看集群信息
3.  先还原之前的3主3从
1. 先启6381
docker  start  redis-node-1
2.再停6384
docker  stop  redis-node-4
3. 再启6384
docker  start  redis-node-4
4.  主从机器分配情况以实际情况为准
4. 查看集群状态
redis-cli --cluster  自己IP:6381
主从扩容案例
1.  新建6387,6388 两个节点 +  新建后启动+查看是否8节点
2.  进入6387 容器实例内部
docker  exec -it  redis-node-7 /bin/bash
3. 将新增的6387节点(空槽号) 作为master 节点加入源集群
4. 检查集群情况第1次
子主题
5. 重新分派槽号
6. 检查集群情况第2次
7. 为主节点6387 分配节点6388
8. 检查集群情况第3次
主从缩容案例
2. DockerFile解析
1. 是什么
DockerFile  是用来构建Docker镜像的文本文件,是由一条条构建镜像所需的指令和参数构成的脚本.
概述
子主题
官网
https://docs.docker.com/engine/reference/builder/
构建三步骤
编写DockerFile文件
docker build 命令构建镜像
docker  run 依镜像运行容器实例
2. DockerFile 构建过程解析
1. DockerFile  内容基础知识
1. 每条保留字指令都必须为大写字母且后面要跟随至少一个参数
2. 指令按照从上到下,顺序执行
3. # 表示注释
4.  每条指令都会创建一个新的镜像层并对镜像进行提交
5. 执行dockerfile 中的下一条指令直到所有指令都执行完成
2. Dcoker 执行Dockerfile 的大致流程
3. 小总结
子主题
1. DockerFile  需要定义一个Dockerfile,Dockerfile定义了进程需要的一切东西.Dockerfile涉及的内容包括执行的代码
或者是文件,环境变量,依赖包,运行时环境,动态链接库,操作系统的发行版,服务进程和内核进程(当应用进程需要和系统服务
和内核进程打交道,这时需要考虑如何设计namespace的权限控制)等等
2. Docker镜像, 在用Dockerfile定义一个文件后,docker build  时会产生一个Docker 镜像,当运行Docker 镜像时会真正
开始提供服务;
3. Docker容器,容器是直接提供服务的.
总结:   DockerFile  类似中药药方,Docker镜像就是抓的中药, Docker 容器就是中药熬的汤
3. DockerFile 常用命令保留字指令
1`.  参考tomcat8的dockerfile 入门
https://github.com/dokcer-library/tomcat
2. FROM 
基础镜像,当前新镜像是基于哪个镜像的,指定一个已经存在的镜像作为模板,第一条必须是form
3. MAINTAINER
镜像维护者的姓名和邮箱地址
4. RUN
1. 容器构建时需要运行的命令
2. 两种格式
shell格式
exec 格式
3. RUN 是在docker  build  时运行
5. EXPOSE
当前容器对外暴露出的端口
6.WORKDIR
指定在创建容器后,终端默认登录的进来的工作目录,一个落脚点
7.USER
指定该镜像以什么样的用户去执行,如果都不指定,默认是root
8. ENV
用来在构建镜像过程中设置环境变量
9. ADD
将宿主机目录下的文件拷贝进镜像且自动处理URL和解压tar压缩包
10. COPY
类似ADD, 拷贝文件和目录到镜像中.
将从构建上下文目录中<源路径>的文件/目录复制到新的一层的镜像内<目标路径>位置
1. COPY  src  desc
2. COPY  ["src","dest"]
3. <src 原路径>:  源文件或者源目录
4.  <dest 目标路径>:  容器内指定路径,改路径不用事先建好,路径不存在的话,
会自动创建.
11. VOLUNE
容器数据卷, 用于数据保存和持久化工作
12. CMD
1.  指定容器启动后的要干的事情
2.  注意
Dockerfile 中可以有多个CMD指令, 但只有最后一个生效,CMD 会被Docker run  之后的参数替换
参考官网Tomcat  的dockerfile  演示讲解
官网最后一行命令
子主题
我们演示自己的覆盖操作
子主题
3. 它和前面RUN命令的区别
CMD 是在docker  run时运行
RUN 是docker build 时运行
13.ENTERPOINT
1. 也是用来指定一个容器启动时要运行的命令
2. 类似CMD指令,但是 ENTERPOINT  不会被docker run 后面的命令覆盖,
而且这些命令行参数会被当作参数送给ENTERPOINT 指令指定的程序
3. 命令格式和案例说明
案例说明
4, 优点
5. 注意
14.小总结
子主题
4. 案例
1.  自定义镜像mycentisjava8
1. 要求
Centos7镜像具备vim +ifconfig+jdk8
JDK的下载镜像地址
https://mirrors.yangxingzhen.com/jdk/
官网
2. 编写
准备编写Dockerfile文件
大写字母D
3. 构建
docker  build  -t  新镜像名字:TAG  .
注意,上面TAG后面有个空格,有个点
4.运行
5. 在体会下UnionFS(联合文件系统)
子主题
2. 虚悬镜像
1. 是什么
仓库名,标签都是<none>的镜像,俗称dangling  image
Dockerfile  写一个
子主题
2.  查看
docker  image  ls  -f  dangling= true
命令结果
3. 删除
子主题
4. 概念
构建时候或者删除时候出现错误,导致仓库和标签都为none
3. 家庭作业- 自定义镜像myubuntu
1. 准备编写 Dockerfile 文件
2. docker  build -t  新镜像名字:TAG  .
3. docker  run  -it  新镜像名字:  TAG
5. 小总结
子主题
3. Docker 微服务实战
通过IDEA 新建一个普通微服务模块
通过dockerfile 发布微服务部署到docker 容器
1. IDEA  工具里面搞定微服务jar包
2. 编写Dockerfile
Dockerfile 内容
将微服务jar包和Dockerfile  文件上传到同一个目录下/mydocker
3. 构建镜像
docker  build  -t  shaolin_docker:1.6  .
打包成镜像文件,用上面的命令
4. 运行容器
5. 访问测试
4. Docker网络
1. 是什么
docker  不启动时候,默认网络情况
图解
ens33
lo
virbr0
在Centos7  的安装过程中如果选择相关虚拟化的服务安装系统后,启动网卡时会发现有一个以
网桥连接的私网地址的virbr0网卡(它还有一个固定的默认IP地址192.168.122.1), 是做虚拟机网桥的使用的,
其作用是为连接其上的虚拟网卡提供的NAT访问外网的功能.

我们之前学习Linux安装,勾选安装系统的时候附带libvirt 服务才会生成的一个东西,如果不需要可以直接将libvirtd
服务卸载, 
yum remove  libvirt-libs.x86_64
docker启动后,网络情况
子主题
查看docker网络模式命令
子主题
2. 常用命令
All  命令
查看网络
docker  network  ls
查看网络源数据
docker  network  inpect    xxx网络名字
删除网络
docker  network    rm  xxx 网络名字
案例
子主题
3. 能干嘛
1. 容器间的互联和通信以及端口映射
2. 容器IP变动时候可以通过服务名字节网络通信而不受影响
4. 网络模式
1. 总结介绍
1. bridge模式
使用--network  bridge 指定, 默认使用docker0
2.  host 模式
使用 --network  host指定
3. none 模式
使用 --network  none指定
4. container  模式
使用 --network  container:NAME 或者容器ID 指定
2. 容器实例内默认网络IP生产规则
说明
图1
图2
图3
结论
docker 内容器IP 是有可能发生改变的
3. 案例说明
1. bridge
是什么
子主题
案例
说明
文字说明
图片说明
代码
docker  run  -d  -p  8081:8080
docker  run -d  -p   8082:8080
两两匹配验证
2.  host
1. 是什么
直接使用宿主机的IP 地址与外界进行通信, 不在需要额外进行NAT转换
2. 案例
说明
容器将不会获得一个独立的Network  Namespace, 而是和宿主机共用一个Network  Namespace
,容器将不会虚拟出自己的网卡而是使用宿主机的IP 和端口.
子主题
代码
警告
docker  run  -d -p  8083:8080  --network  host  --name  tomcat83  billygoo/tomcat8-jdk8
子主题
正确
docker run -d --network host --name tomcat83 billygoo/tomcat8-jdk8
无之前的配对显示了.看容器实例内部
子主题
没有配置-p的端口映射了, 如何访问启动的tomcat8
http://宿主机IP:8080/
在Centos 里面用默认的火狐浏览器访问容器内的tomcat83 看到访问成功, 因为此时容器的IP借用主机的,
所以容器共享宿主机网络IP,这样的好处是外部主机与容器可以直接通信.
3.  none
是什么
禁用网络功能,只有lo标识(就是127.0.0.1表示本地回环)
案例
在none模式下,并不为Docker 容器进行任何网络配置.
也就是说,这个Docker容器没有网卡,IP,路由等信息,只有一个lo
需要我们自己为Docker容器添加网卡,配置IP等.
docker  run  -d -p 8084:8080  --network  none  --name  tomcat84  billygoo/tomcat8-jdk8
4. 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
运行结果
子主题
案例
Alpine  操作系统是一个面向安全的轻型Linux 发型版
docker  run  -it    --name  alpine1  alpine  /bin/sh
docker run  -it  0network  container:alpine1 --name  alpine2  alpine  /bin/sh
运行结果,验证共用搭桥
假如此时关闭alpine1, 再看看alpine2
5.  自定义网络
过时的link
是什么
before
案例
docker   run   -d  -p  8081:8080  --name  tomcat81  billygoo/tomcat8-jdk8
docker  run  -d -p  8082:8080  --name  tomcat82  billygoo/tomcat8-jdk8
上述成功启动并用docker  exec   进入各自容器实例内部
问题
按照IP地址ping 是ok的
子主题
按照服务名ping结果
子主题
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测试
docker   exec  -it  容器名  bash
ping   容器名称
问题结论
自定义网络本身就维护好了主机名和ip的对应关系(ip  和域名都能通)
自定义网络本身就维护好了主机名和ip的对应关系(ip  和域名都能通)
自定义网络本身就维护好了主机名和ip的对应关系(ip 和域名都能通)
案例
5. Docker 平台架构图解
整体说明
整体架构
图1
图2
5. Docker-compose  容器编排
1. 是什么
Docker-Compose  是Docker 官方的开源项目,负责实现对Docker 容器集群的快速编排.
2. 能干嘛
docker建议我们每一个容器中只运行一个服务,因为docker容器本身占用资源极少,所以最好是将每个服务单独的分割开来但是这样我们又面临了一.
问题?
如果我需要同时部署好多个服务,难道要每个服务单独写Dockerfle然后在构建镜像,构建容器,这样累都累死了,所以docker官方给我们提供了docker-compose多服务部署的工具
例如要实现一个Web微服务项目，除了Web服条容器本身，往往还需要再加上后端的数据库mysa服务容器，redis服务器，注册中心eureka，甚至还包括负载均衡容器等等。。。。。。
Compose允许用户通过一个单独的docker-compose.yml模板文件(YAML 格式)来定义一组相关联的应用容器为一个项目(proiect)
可以很容易地用一个配置文件定义一个多容器的应用，然后使用一条指今安装这个应用的所有依赖，完成构建。Docker-Compose 解决了容器与容器之间如何管理编排的问题。
3. 去哪下
官网
http://docs.docker.com/compose/compose-file/compile-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
子主题
卸载步骤
4. Compose核心概念
一文件
docker-compose.yml
两要素
服务(service)
一个个应用容器实例,比如订单微服务,库存微服务,mysql容器,nginx容器或者redis容器
工程(project)
由一组关联的应用容器组成的一个完整业务单元,在docker-compose.yml文件中定义.
5. Compose  使用的三个步骤
1. 编写Dockerfile 定义各个微服务应用并构建对应的镜像文件
2. 使用docker-compose.yml,  定义一个完整业务单元,安排好整体应用中的各个容器服务.
3. 最后, 执行docker-compose   up 命令 来启动并运行整个应用程序,完成一键部署上线
6. 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  restart 
重启服务
docker-compose  start
启动服务
docker-compose  stop
停止服务
7. Compse 编排微服务
1. 改造升级微服务工程docker_boot
通过idea新建一个普通微服务模块
通过dockerfile发布微服务部署到docker容器
2. 不用Compose
1, 单独的mysql 容器实例
新建mysql 容器实例
进入 mysql容器实例并新建库db2021+ 新建表t_user
2. 单独的redis 容器实例
3. 微服务工程
4. 上面三个容器实例一次顺序启动成功
3. swagger测试
http://localhost:port/swagger-ui.html#/
4. 上面成功了, 有哪些问题
先后顺序要求固定,先mysql+redis 才能微服务访问成功
多个run 命令
容器间的启停或者宕机,有可能导致IP地址对应的容器实例变化,映射出错,要么生产IP写死(不推荐), 要么通过服务调用
5. 使用compose
1. 服务编排,一套带走
2. 编写docker-compose.yml文件
3. 第二次修改微服务工程docker_boot
写yml
通过服务名访问,IP无关
mvn  package  命令将微服务形成新的jar包并上传到liux 服务器/my/mydocker  目录下
编写Dockerfile
构建镜像
docker  build -t  zzyy_docker:1.6  .
4. 执行docker-compose  up  或者docker-compose  up  -d
5. 进入mysql  容器实例并新建库db2021+新建表t_user
6. 测试通过
7. Compose 常用命令
8. 关停
6. Docker  轻量级可视化工具Portainer
是什么
Portainer  是一款轻量级的应用,它提供了图形化界面,用于方便管理Docker 环境,包括单机环境和集群环境.
安装
官网
https://www.portainer.io/
https://docs.portainer.io/v/ce-2.9/start/install/server/docker/linux
登录并演示介绍常用操作case
1. docker  命令安装
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
2. 第一次登录需创建admin,访问地址: xxx.xxx.xxx.xxx:9000
3. 设置admin用户和密码后首次登录
4. 选择local 选项卡后本地docker  详细信息展示
5. 上一步的图形展示,能想得起对应命令嘛
7. Docker 容器监控之CAdvisor+ InfluxDB + Granfana
1.  原生命令
操作
docker  stats
问题
通过docker  stats  命令可以很方便的看到当前宿主机上所有容器的CPU,内存以及网络流量等数据,一般小公司够用了,
但是,  docker  stats  统计结果只能是当前宿主机的全部容器,数据资料是实时的,没有地方存储,没有健康指标过线预警等功能
2. 是什么
容器三剑客
一句话
CAdvisor   监控收集+InfluxDB  存储数据+Granfana 展示图表
CAdvisor
CAdvisor  是一个 容器资源监控工具, 包括容器的内存,网络IO,磁盘IO等监控,同时提供了一个WEB页面
用于查看容器的实时运行状态,CAdvisor 默认存储2分钟的数据,而且只是针对单物理机,不过, CAdvisor提供
了很多数据集成接口,支持InfluxDB,Redis,Kafka,Elasticsearch等集成,可以加上对应配置将监控数据发往这些数据库存储起来
特点: 
展示Host  和容器两个层次的监控数据
展示历史变化数据
InfluxDB
介绍
InfluxDB  是用Go 语言编写的一个开源分布式时序,事件和指标数据库,无需外部依赖.
特点
CAdvisor  默认只在本机保存最近2分钟的数据,为了持久化存储数据,和统一收集展示监控数据,需要将数据
存储到InfluxDB中,InfluxDB是一个时序数据库,专门用于存储时序相关数据,很适合存储CAdvisor的数据,而且,
CAdvisor本身已经提供InfluxDB的集成方法,启动容器时指定配置即可.
功能
1. 基于事件序列,支持与时间有关的相关函数(如最大,最小,求和等)
2.  可度量性,你可以实时对大量数据进行计算
3. 基于事件,它支持任意的事件数据;
Granfana
概念
Granfana 是一个开源的数据监控分析可视化平台, 支持多种数据源配置(支持的数据源包括InfluxDB,MYsql,Es,OpenTSDB,Graphite等)和丰富的插件以及模板功能,支持图表权限控制和报警
特性
1.  灵活丰富的图形化选项
2. 可以混合多种风格
3. 支持白天和夜间模式
4. 多个数据源
总结
3. compose 容器编排,一套带走
1.  新建目录
2. 新建3件套组合的 docker-compose.yml 
3. 启动docker-compose 文件
4.   查看三个服务容器是否启动
5.测试
8.  终章&总结
评论
0 条评论
下一页
为你推荐
查看更多
Docker
Docker
Docker总结
Docker总结
Docker
Docker
Docker
Docker
Docker
Docker
容器Docker
容器Docker
Docker
Docker
Docker基础
Docker基础
docker
docker
Docker
Docker