Docker

1、容器技术

​ Linux容器技术（Linux Containers，缩写LXC）：是与系统其他部分分隔开的一系列进程，从另一个镜像运行，并由该镜像提供支持进程所需的全部文件。它在操作系统层面实现了虚拟化，直接复用本地主机操作系统，并不是像虚拟机一样模拟一个完整的操作系统而是对进程进行隔离。容器提供的镜像包含了使用的所有依赖，因而在从开发到测试再到生产的整个过程中，它都具有可移植性和一致性。

为什么会有容器的出现，它的出现解决了什么问题？

​ 在容器技术出现之前，软件编码开发/测试结束后，所产生的成果既是能够编译的二进制字节码，为了让这些程序可以顺利地执行，开发团队需要准备完整的部署文件，清楚地告知运维团队程序所用的全部配置文件和软件运行环境，运维团队需要在新的服务器按照相关文档，再次配置一个相同的应用运行环境，部署文档，安装各种如Java、RabbitMQ、MYSQL、JDBC驱动包等复杂软件，这个过程不仅麻烦繁琐，而且非常容易出错，如果遇到多台集群、扩容、缩容问题，这个过程的繁琐更加难以想象。这个时候，就希望能够有一种方法技术，能够快速地平滑迁移这些环境。人们开始想到的是使用虚拟机技术，将整个环境乃至系统全部复制出来，重新在一个虚拟系统上进行操作，在Docker出现之前，这个方法的确是在一段时间解决了安装配置问题，但是它的问题也是显著的，我们知道，安装一个系统本身就会占用计算机大量的内存，随着应用的增加，内存占用会越来越大，这样不仅对内存的压力大，由于每次开启应用都需要去加载一遍所有系统文件，导致应用开启也会越来越慢。虚拟机之所以能够在一台服务器上创造出多个虚拟操作系统，是因为采用了镜像文件，这个镜像文件就相当于是操作系统，只要有相应的镜像文件，在服务器内存足够下，就能创建出多个操作系统，容器技术就参照了虚拟机的镜像原理，将需要使用的源码+配置+环境+各种版本等除作业系统核心外的运作应用程序所需要的系统环境打包成一个镜像文件，再配合容器引擎，就能在不同的服务器上创建出相同的程序运行环境。这样既减少了像虚拟机所需要占用的大量内存，启动速度快，又能解决在研发环境、测试环境以及生产环境下运行程序产生的结果不一致问题（同一套代码，在研发环境可运行，在其他环境不行）

​ Docker技术就是容器技术中的一种（Docker本身是一个容器运行载体/管理引擎），它是基于Go语言实现的云开源项目，依赖于已存在并运行的Linux内核环境，必须部署在Linux内核的系统上。目标是：“Build，Ship and Run App Anywhere”，通过对引用组建的封装、开发、部署、运行等生命周期的管理，使用户的APP及其运行环境能够做到：一次镜像，处处运行。其他的容器技术还有 K8s(Kubernetes)、OpenShift、AWS EKS、Docker Swarm等。

Docker三要素：镜像、容器、仓库

学习docker，首先需要理解它的三要素

镜像：

1、Docker镜像（Image就是一个只读的模板）。镜像可以用来创建Docker容器，一个镜像可以创建很多容器。
2、它也相当于是一个root文件系统。比如官方镜像centos:7就包含了完整的一套centos:7最小系统的root文件系统。
3、相当于容器的“源代码”，docker镜像文件类似于java的类模板，而docker容器示例类似于java中new出来的实例对象

容器：

从面向对象角度：
Docker利用容器独立运行的一个或一组应用，应用程序或服务运行在容器里面，容器就类似于一个虚拟化的运行环境，容器是用镜像创建的运行实例。就像是Java中的类和实例对象一样，镜像是静态的定义，容器是镜像运行时的实体。容器为镜像提供了一个标准的和隔离的运行环境，它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台

从镜像容器角度：
可以把容器看做是一个简易版的Linux环境（包括root用户权限、进程空间、用户空间和网络空间等）和运行在其中的应用程序。image文件生成的容器实例本身也是一个文件，称为镜像文件

仓库：

仓库（Repository)是集中存放镜像文件的场所 ，分为公开库（public）和私有仓库（Private）两种形式

Docker公司提供的官方registry被称为Docker Hub,存放各种镜像模板的地方

2、使用原理、环境搭建

Docker是一个Client-Server结构的系统，Docker守护进程运行在主机上，然后通过Socker连接从客户端访问，守护进程从客户端接受命令并管理运行在主机上的容器。

使用原理

整体架构及底层通信原理：

1、用户是使用Docker Client 与 Docker Daemon 建立通信，并发送请求给后者

2、Docker Daemon 作为Docker架构中的主体部分，首先提供Docker Server的功能使其可以接受Docker Client的请求

3、Docker Engine 执行Docker 内部的一系列工作，每一项工作都是以一个job的形式存在

4、Job的运行过程中，当需要容器镜像时，则从Docker Registory中下载镜像，并通过镜像管理驱动Graph driver将下载镜像以Graph的形式存储

5、当需要为docker创建网络环境时，通过网络管理驱动Network driver创建并配置Docker容器网络环境

6、当需要限制Docker容器运行资源或执行用户指令操作时，则通过Exex driver 来完成

7、Libcontainer 是一项独立的管理包，NetWork driver 以及Exec driver都是通过Libcontainer来实现具体对容器进行的操作

环境搭建

注：由于本人是Windows系统，所以以下所有操作都在虚拟机上创建其它操作系统（此处是centos）完成，虚拟机操作系统创建请见其它章节

docker官网 ：http://www.docker.com

Docker Hub 官网（docker镜像仓库）：https://hub.docker.com/

https://docs.docker.com/engine/install/centos/
1
2
3
4
5

前提条件：

目前，CentOS仅发行版本中的内核支持Docker。Docker运行在CentOS 7(64-bit)上，要求系统为64位、Linux系统内核版本为3.8以上，选择CentOS7.x

查看自己的内核：

uname命令用于打印当前系统相关信息（内核版本号、硬件架构、主机名称和操作系统类型等）

cat /etc/redhat-release
1

uname -r
1

卸载旧版本docker：

yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
1
2
3
4
5
6
7
8

步骤一：yum安装gcc相关

yum -y install gcc
1

yum -y install gcc-c++
1

步骤二：安装需要的软件包

yum install -y yum-utils
1

步骤三：添加稳定的镜像源（镜像仓库）

此处是添加阿里云的镜像源

yum-config-manager  --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
1

如果出现找不到mirrors.aliyun.com的问题，需要在resolv.conf中添加地址ip

vi resolv.conf
添加：
mirrors.aliyun.com 122.225.214.225
1
2
3

步骤五：更新yum软件包索引

yum makecache fast
1

步骤六：安装Docker CE

yum -y install docker-ce docker-ce-cli containerd.io
1

步骤七：启动docker

systemctl start docker
1

步骤八：查看docker启动状态

查看进程
ps -ef|grep docker
查看版本
docker version
1
2
3
4

步骤九：配置阿里云镜像加速器

1、注册一个阿里云账号（https://promotion.aliyun.com/ntms/act/kubernetes.html）

2、登录阿里云开发者平台，点击控制台–>右侧菜单栏–>搜索‘容器镜像服务’–>镜像工具–>镜像加速器–>复制加速器地址

3、将下面的复制并替换成自己的阿里云加速器地址，存放在一个/etc/docker/daemon.json下

新建目录

mkdir -p /etc/docker
1

tee /etc/docker/daemon.json <<-'EOF'
1

{
  "registry-mirrors": ["https://***1xe.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
1
2
3
4
5
6

4、重新加载配置文件

systemctl daemon-reload
1

5、重启docker

systemctl restart docker
1

6、检查

docker run hello-world
1

docker run的运行过程：

常用命令

1、帮助启动类命令

启动docker

systemctl start docker
1

停止docker

systemctl stop docker
1

注：每次停止停止docker 命令执行完都会提示以上警告，因为除了docker.service单元文件，还有一个docker.socket单元文件，如果试图连接到docker socket，而docker服务没有运行，系统将自动启动docker解决方法：输入命令：

sudo systemctl stop docker.socket
1

重启docke

systemctl restart docker
1

查看docker状态

systemctl status docker
1

开机启动（设置一开机便自动启动docker）

systemctl enable docker
1

查看docker概要信息

docker info
1

查看docker总体帮助文档

docker --help
1

查看docker命令帮助文档

docker 具体命令 --help
1

2、镜像命令

• 列出本地主机上的镜像文件

docker images
1

注：同一个仓库源可以有多个TAG版本，代表这个仓库源的不同版本，我们使用REPOSITIRY:TAG来定义不同的镜像。
如果不指定一个镜像的版本标签，例如只使用ubuntu，docker将默认使用ubuntn:latest镜像

• 在仓库查找相关镜像

  也可直接在 https://hub.docker.com 上查看

docker search 某个镜像的名字
1

• 下载镜像

docker pull 某个镜像的名字:TAG
1

注：没有TAG就是最新版，等价于

docker pull 镜像名字：latest
1

• 查看镜像/容器/数据卷所占的空间

docker system df 
1

• 删除镜像

docker rmi 某个镜像名字ID
1

删除单个镜像

docker rmi -f 镜像ID
1

删除多个镜像

docker rmi -f 镜像名1::TAG 镜像名2:TAG
1

删除全部

docker rmi -f $(docker images -qa)
1

• docker虚悬镜像

  仓库名、标签都是的镜像，俗称虚悬镜像dangling image

3、容器命令

前提：容器命令的执行建立在容器之上，容器的生成建立在镜像之上，因此首先需要下载一个镜像（此处案例使用ubuntu，也可使用CentOS）

docker pull ubuntu
1

• 新建+启动容器

docker run [OPTION]NAME[COMMAND][ARG...]
1

注：Docker容器后台运行，就必须有一个前台进程，否则会自动退出(如果不是一些一直挂起的命令，如top,tail等）
解决方案：将要运行的程序以前台进程形式运行，常见的就是命令行模式

• 退出容器

方式一：run进去容器，exit退出，容器停止

exit
1

方式二：run进去容器，ctrl+p+q退出，容器不停止

ctrl+p+q
1

• 列出所有当前正在运行的容器

docker ps [OPTIONS]
1

• 启动已停止运行的容器

docker start 容器ID或者容器名
1

• 重启容器

docker restart 容器ID或者容器名
1

• 停止容器

docker stop 容器ID或者容器名
1

• 强制停止容器

docker kill 容器ID或者容器名
1

• 删除已停止的容器

docker rm 容器ID或者容器名
1

• 一次性删除多个容器实例

docker rm -f ${docker ps  -a -q)
1

docker ps -a -q | xargs docker rm
1

• 查看容器日志

docker logs  容器ID或者容器名
1

• 查看容器内运行的进程

docker top 容器ID或者容器名
1

• 查看容器内部细节

docker inspect 容器ID
1

• 进入正在运行的容器并以命令行交互

  方式一：

docker exec -it 容器ID/容器名称 bashShell
1

​ 方式二：

docker attach 容器ID
1

区别：attach直接进入容器启动命令的终端，不会启动新的进程，用exit退出，会导致容器停止；exec是在容器中打开新的终端，并且可以启动新的进程，用exit退出，不会导致容器的终止

• 从容器内拷贝文件到主机上

docker cp 容器ID：容器内路径  目的主机路径
1

导出和导入容器

docker export 容器ID > 文件名.tar
1

cat 文件名.tar | docker import - 镜像用户/镜像名:镜像版本号
docker run -it --name 镜像名 镜像用户/镜像名:镜像版本号 /bin/bash
1
2

镜像

是什么

一种轻量级、可执行的独立软件包，它包含运行某个软件所需的所有内容，我们把应用程序和配置依赖打包好形成一个可交互的运行环境（包括代码、运行时需要的库、环境变量和配置文件等），这个打包好的运行环境就是image镜像文件

UnionFS（联合文件系统）:

一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层一层的叠加，同时将不同目录挂载到同一个虚拟文件系统下。是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就是各种不同的操作系统发行版，比如Ununtu，Centos等等

为什么Docker镜像要采用这种分层结构

镜像分层最大的一个好处就是共享资源，方便复制迁移，复用

比如说有多个镜像都从相同的base镜像构建而来，那么Docker Host只需要在磁盘上保存一份base镜像。
同时内存中也只需要加载一份base镜像，就可以为所有的容器服务。并且镜像的每一层都是可以被共享。

注：Docker镜像层都是只读的，容器层是可写的
当容器启动时，一个新的可写层被加载到镜像的顶部。这一层通常被称为 ”容器层“，“容器层”之下的都叫“镜像层”

Docker镜像commit操作案例

命令：提交容器副本使之成为一个新的镜像

docker commit -m="提交的描述信息“ -a="作者” 容器ID要创建的目标镜像名:[标签名]
1

演示ubuntu安装vim：

步骤一：原始的默认Ubuntu镜像是不带vim命令的

步骤二：外网连通的情况下，ubuntu下安装vim

apt-get update
1

apt-get -y install vim
1

步骤三：安装完成后，docker下commit我们自己的镜像

docker commit -m="add vim cmd" -a="lyx"  容器ID atguigu/ubuntu/myubuntu:1.1
1

步骤四：测试检查

总结：Docker中的镜像分层，支持通过扩展现有镜像，创建新的镜像。类似Java继承于一个Base基础类，自己再按需扩展。新镜像是从base镜像一层一层叠加生成的。每安装一个软件，就在现有镜像的基础上增加一层

镜像发布

镜像生成的两种方法：

• 基于当前容器创建一个新的镜像，新功能增强

docker commit [OPTIONS] 容器ID [REPOSITORY[:TAG]]
1

• 通过Dockerfile文件命令（Dockerfile章节详解）

本地镜像发布到阿里云

本地镜像发布到阿里云流程（两种）：

1、本地生成新的镜像文件->commit生成新的带新的tag的镜像->push到阿里云Docker Registry ->其他人pull镜像到本地

2、Dockerfile命令->build成新的带tag的镜像->push到阿里云Docker Registry->其他人pull镜像到本地

步骤一：进入阿里云开发者平台 https://promotion.aliyun.com

选择 控制台 ，进入容器镜像服务 -> 选择个人实例 -> 命名空间，创建命名空间 -> 镜像仓库，创建镜像仓库 -> 进入管理界面获得脚本，仓库镜像，管理中

步骤二：将镜像推送到阿里云（直接复制自己上界面代码即可，此处代码因镜像仓库不同而异）

docker login --username=阿里云用户账号 registry.cn-hangzhou.aliyuncs.com
1

docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/lyx_docker_namespace/lyx_docker_study:[镜像版本号]
1

docker push registry.cn-hangzhou.aliyuncs.com/lyx_docker_namespace/lyx_docker_study:[镜像版本号]
1

步骤三：查看是否推送成功

docker pull 刚上传的镜像名称:TAG
1

本地镜像发布到私有库

本地镜像发布到私有库流程（两种）：

1、本地生成新的镜像文件->commit生成新的带新的tag的镜像->push到私有Docker Registry ->其他人pull镜像到本地

2、Dockerfile命令->build成新的带tag的镜像->push到私有Docker Registry ->其他人pull镜像到本地

步骤一：下载镜像Docker Registry，用于构建私有镜像仓库

docker pull registry
1

步骤二：运行私有库Registry，相当于本地有个私有Docker hub

默认情况，仓库被创建在容器的/var/lib/regiistry目录下，建议自行用容器卷映射，方便于宿主机联调

docker run -d -p 5000:5000 -v /lyzuse/myregistry/:/tmp/registry --privileged=true registry
1

步骤三：docker下commit自己的镜像

docker commit -m="vim cmd add" -a="lyx" 容器ID  容器名称:TAG
1

步骤四：curl验证私服库上有什么镜像(目前是没有镜像的)

ip地址为宿主机地址，需要开启5000端口号或者关闭防火墙，注：registry容器需要启动

docker start registry
1

curl -XGER http://ip:5000/v2/_catalog
1

步骤五：将新镜像ubuntu:1.2修改符合私服规范的Tag

docker tag 镜像:Tag Host:Port/Repository:Tag
1

步骤六：修改配置文件使之支持http

cat /etc/docker/daemon.json
1

修改 insecure-registries对应的value为：ip:5000
理由：docker默认不允许http方式推送镜像，通过配置选项来取消这个限制，修改完后如果不生效，则重启docker尝试

步骤七：push推送到私服库

docker push ip:5000/myubuntu01:2.0.0
1

步骤八：curl验证私服上有什么镜像2

curl -XGET http://ip:5000/v2/_catalog
1

步骤九：pull到本地测试

docker pull ip:5000/myubuntu01:2.0.0
1

容器数据卷

是什么

容器数据卷类似Redis中的rdb和aof文件。是由docker挂载到一个或多个容器中的文件，能够将docker容器内的数据保存进宿主机的磁盘中。它不属于联合文件系统，可以绕过Union File System提供一些用于持久存储或共享数据的特性，完全独立于容器的生命周期。可以完成数据的持久化重要资料备份，通过地址映射，将容器内的数据备份+持久化到本地主机目录，防止容器实例删除后，容器内的数据也没有了。

特点

• 数据卷可在容器之间共享或重用数据
• 卷中的更改可以直接实时生效
• 数据卷中的更改不会包含在镜像的更新中
• 数据卷的生命周期一直持续到没有容器使用它为止

命令

默认情况，仓库被创建在容器的/var/lib/regiistry目录下，建议自行用容器卷映射，方便于宿主机联调

docker run -it  --privileged=true -v /宿主机绝对路径目录:/容器内目录:读写权限(默认读写权限rw，ro为只读)  镜像名称
1

注：–privileged=true 容器扩权，必须携带该参数，否则会出现警告 cannot open directory,:Permission denied

原因：CentOS7安全模块会比之前系统版本加强，不安全的会先禁止，所以目录挂载的情况被默认为不安全的行为；在SELinux里面挂载目录被禁止掉了，如果要开启，一般使用这个命令，扩大容器的权限解决挂载目录没有权限的问题，即使用改参数，container内的root拥有真正的root权限，否则，container内的root只是外部的一个普通用户权限

案例

宿主机和容器1之间映射添加容器卷

docker run -d -p 5000:5000 -v /lyzuse/myregistry/:/tmp/registry --privileged=true registry
1

查看数据卷是否挂载成功

docker inspect 容器ID
1

容器1与宿主机之间数据共享：容器与宿主机建立容器卷后，数据实时共享

宿主机和容器2之间映射添加容器卷，设置容器内部只读，查看容器2内部读写权限

docker run -d -p 5000:5000 -v /lyzuse/myregistry/:/tmp/registry:ro --privileged=true registry
1

容器3继承容器2的卷规则

docker run -it --priviledge=true --volumes-from 父类 --name u2 ubuntu
1

其它常规软件安装案例

安装tomcat

下载tomcat镜像

docker pull tomcat
1

查看tomcat是否下拉成功

docker images tomcat
1

使用tomcat镜像创建容器实例

docker run -it -p 8080:8080 tomcat
1

访问tomcat首页

解决：把webapps.dist目录换成webapps

docker exec -it tomcat的容器ID /bin/bash
pwd
ls -l
cat webapps
rm -r webapps
mv webapps.dist webapps
1
2
3
4
5
6

访问tomcat首页

安装mysql

查找docker hub上是否有mysql镜像

docker search mysql
1

拉取mysql镜像到本地标签为5.7

docker pull mysql:5.7
1

新建mysql容器实例

docker run -d -p 3306:3306 --privileged=true -v /lyxuse/mysql/log:/var/log/mysql -v /lyxuse/mysql/data:/var/lib/mysql -v /lyxuse/mysql/conf:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=123456 --name mysql mysql:5.7
1

新建my.cnf，自动同步至容器实例中，目的是为了解决docker上默认字符集编码隐患，插入中文数据报错

cd /lyxuse/mysql/conf
ls -l
vim my.cnf

[client]
default_character_set=utf8
[mysqld]
collation_server = utf8_general_ci
character_set_server = utf8 

cat my.cnf
1
2
3
4
5
6
7
8
9
10
11

重新启动mysql容器实例再重新进入并查看字符编码

docker restart mysql
1

docker exec -it mysql bash
1

mysql -uroot -p
SHOW VARIABLES LIKE 'character%';
1
2

未建立my.cnff时：

重新启动mysql容器实例再重新进入并查看字符编码

docker restart mysql
1

docker exec -it mysql bash
1

mysql -uroot -p
SHOW VARIABLES LIKE 'character%';
1
2

安装redis

拉取redis镜像

docker pull redis:6.0.8
1

查看redis镜像是否拉取成功

docker images redis:6.0.8
1

宿主机centos下新建目录

mkdir -p /app/redis
1

下载redis.conf：https://redis.io/docs/manual/config/ （也可以在官网吧把redis下载下来，再提取redis.conf进行修改）

将准备好的redis.conf文件拷贝进/app/redis目录下

cp /myredis/redis.conf /app/redis/
1

/app/redis目录下修改redis.conf文件

1、开启redis验证（可选）：
requirepass 123
2、允许redis外地连接，必须注释掉：
# bind 127.0.0.1
3、将daemonize yes注释起来或者daemonize no设置
原因：该设置和docker run中-d参数冲突，会导致容器一直启动失败
4、开启redis数据持久化 appendonly yes（可选）
1
2
3
4
5
6
7

运行容器

docker run -it -p 6379:6379 --privileged=true -v /app/redis/redis.conf:/etc/redis/redis.conf -v /app/redis/data:/data --name myredis  redis:6.0.8 redis-server /etc/redis/redis.conf
1

测试redis-cli连接

docker exec -it redis容器ID /bin/bash

redis-cli
auth 123456
set k1 v1
get k1
select 15
1
2
3
4
5
6
7

验证目前使用的配置是我们的redis.conf配置文件

将宿主机的/app/redis/redis.conf 中的 databases 16 改成 databases 10

docker restart myredis
docker exec -it myredis /bin/bash
redis-cli
auth 123456
select 9
select 10
1
2
3
4
5
6

安装Nginx

关于mysql主从复制

主从复制原理

主从复制搭建

步骤一：新建主服务器容器实例3307

docker run -p 3307:3306 --privileged=true --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
1

docker ps
1

步骤二：进入/mydata/mysql-master/conf目录下新建my.cnf

vim my.cnf

[client]
default_character_set=utf8

[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端复制中断
## 如：1602错误是指一些主键重复，1032错误是因为主从数据库数据不一致
slave_skip_errors=1062
collation_server = utf8_general_ci
character_set_server = utf8
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

步骤三：修改完配置后重启master实例

docker restart mysql-master
1

docker ps
1

步骤四：进入mysql-master容器

docker exec -it mysql-master /bin/bash
1

步骤五：master容器实例内创建数据同步用户

mysql -uroot -proot
1

CREATE USER 'slave'@'%' IDENTIFIED BY '123456';
1

GRANT REPLICATION SLAVE,REPLICATION CLIENT ON *.* TO 'slave'@'%';
1

步骤六：新建从服务器容器实例3308

docker run -p 3308:3306 --privileged=true --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
1

docker ps -a
1

步骤七：进入/mydata/mysql-slave/conf目录下新建my.cnf

cd /mydata/mysql-slave/conf
vim my.cnf

[client]
default_character_set=utf8

[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端复制中断
## 如：1602错误是指一些主键重复，1032错误是因为主从数据库数据不一致
slave_skip_errors=1062
## relay_log配置中继日志
relay_log=mall-mysql-relay-bin
## log_slave_update表示slave将复制事件写进自己的二进制日志
log_slave_updates=1
## slave设置只读（具有super权限的用户除外）
read_only=1
collation_server = utf8_general_ci
character_set_server = utf8
1
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

步骤八：修改完配置后重启slave实例

docker restart mysql-slave
1

docker ps -a
1

步骤九：在主数据库中查看主从同步状态

show master status;
1

步骤十：进入mysql-slave容器

docker exec -it mysql-slave /bin/bash
1

mysql uroot -proot
1

步骤十一：在从数据库中配置主从复制

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

步骤十二：在从数据库中查看主从同步状态

show slave status \G;
1

步骤十三：在从数据库中开启主从同步

start slave;
1

步骤十四：查看从数据库状态发现已经同步

show slave status \G;
1

步骤十五：主从复制测试

主机新建库-使用库-新建表-插入数据

create database db01;
use db01;
create table t1(id int,namne varchar(20));
show tables;
insert into t1(id,name) values(1,'lili');
select * from t1;
1
2
3
4
5
6

从机使用库-查看记录

关于redis集群(扩缩容)

小知识

问题：1~2亿条数据需要缓存，如何设计存储案例

解决方法：

• 哈希取余分区

  分布式存储，将数据存储在多机上，用户每次读写操作都是根据公式：hash(key)%N个机器台数，计算出哈希值，用来决定数据映射到哪一个节点上

  优点：
  简单有效，只需要预估好数据规划好节点。起到负载均衡+分而治之的作用

  缺点：
  当发生扩容或者缩容时，每次数据变动导致节点变动，映射关系就需要重新进行计算，原来的取模公式会发生变化，从而导致取余运算的结果也发生很大的变化，公式获取的服务器变得不可控

• 一致性哈希算法分区

  解决问题：服务器个数发生变化时，尽量减少影响客户端到服务器的映射关系

  步骤：

  1、算法构建一致性哈希环：对2^{32-1取模，使整个哈希值空间组织成一个虚拟的圆环（注：hash空间的大小为[0,2}32-1]

  2、服务器IP节点映射：将集群中各个IP节点映射到环上的某一个位置。将服务器使用Hash进行一个哈希，具体可以选择服务器的IP或主机名作为关键字进行哈希，这样每台机器就能确定其在哈希环上的位置

  3、key落到服务器的落键规则：当我们需要存储一个kv键值对时，首先计算key的hash值，hash(key)，将这个key使用相同的函数Hash计算出哈希值并确定此数据环上的位置，从此位置沿环顺时针行走，第一台遇到的服务器就是其应该定位到的服务器，并将该键值对存储在该节点上

  优点：
  解决了容错性、扩展性

  缺点：
  存在数据倾斜问题

  总结：为了在节点数目发生改变时尽可能少地迁移数据。将所有的存储点排列在首尾相接的Hash环上，每个key在计算Hash后会顺时针找到临近的存储节点存放，而当有节点加入或退出时仅影响该节点在Hash环上顺时针相邻的后续节点。
  优点是：加入和删除节点只影响哈希环中顺时针方向的相邻的节点，对其他节点无影响
  缺点是：数据的分布和节点的位置上有关，因为这些节点不是均匀分布在哈希环上，所以数据在进行存储时达不到均匀分布的效果

• 哈希槽分区

  哈希槽实质就是一个数组，数组[0,2^14-1]形成hash slot空间

  解决均匀分配问题，在数据和节点之间加入了一层，把这层称为哈希槽（slot），用于管理数据和节点之间的关系，相当于节点上放的是槽，槽里放的是数据。槽解决的是粒度问题，相当于吧粒度变大，便于数据移动。哈希解决的是映射问题，使用key的哈希值来计算所在的槽，便于数据分配。

  Redis集群有16384个哈希槽，每个key通过CRC16校验后对16384取模来决定放置在哪个槽，即 slot = CRC16(KEY)%16384 ，集群的每个节点负责一部分hash槽。这些槽分配给集群中的所有主节点，分配策略没有要求，可以指定哪些编号的槽分配给那个主节点，集群会记录节点和槽对应的关系。
  使用16384个哈希槽的原因是：
  1、正常的心跳数据包含有完整的配置，即也包含原始节点的插槽配置，如果槽位太大，发送的心跳会过于庞大，使用16384个哈希槽不会导致消息头过大，浪费带宽
  2、redis的集群主节点数量基本不可能超过1000个
  3、槽位越小，节点少的情况下，压缩比高，容易传输

  哈希槽的计算

  slot = CRC16(KEY)%16384
  System.out.println(SlotHash.getSlot(key:"A"));
  1
  2

3主3从redis集群配置

步骤一：关闭防火墙并重启docker

systemctl stop firewall
1

systemctl restart docker
1

步骤二：新建6个docker容器实例

docker run -d --name redis-node1 --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-node2 --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-node3 --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-node4 --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-node5 --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-node6 --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
9
10
11

步骤三：进入容器redis-node-1并为6台机器构建集群关系

docker exec -it redis-node1 /bin/bash
1

redis-cli --cluster create 192.168.21.130:6381 192.168.21.130:6382 192.168.21.130:6383 192.168.21.130:6384 192.168.21.130:6385 192.168.21.130:6386 --cluster-replicas 1
1

步骤四：链接进入6381作为切入点，查看集群状态

redis- cli -p 6381
1

cluster info
1

cluster nodes
1

主从对应关系：6381-6386 6382-6384 6383-6385 （实际情况根据自己机器分配而定）

主从容错切换迁移案例

问题：数据读写存储

步骤一：启动6台机器构成的集群并通过exec进入

docker exec -it redis-node1 /bin/bash
1

redis-cli -p 6381
1

步骤二：对6381新增两个key（出现计算出来的值超过所分配到的槽的范围，无法存储的问题）

keys *
set k1 v1
set k2 v2
exit
1
2
3
4

步骤三：防止路由失效加参数-c并新增两个key, key会自动分配到相应的redis中

docker exec -it redis-node1 /bin/bash
1

redis-cli -p 6381 -c
1

步骤四：查看集群信息

redis-cli --cluster check 192.168.21.130:6381
1

解决：容错切换迁移

步骤一：主机6381和从机6386切换，先停止主机6381

6381下查看集群

cluster nodes
1

docker stop redis-node1
1

步骤二：查看集群信息（redis-node1停止了，它的slave redis-node6还能正常工作）

docker exec -it redis-node2 bash
1

redis-cli -p 6382 -c
cluster nodes
set k6 v6
1
2
3

步骤三：还原之前的3主3从

docker start redis-node1
1

此时 6381变成了6386的从机，6386变为了主机，其它主从关系未变

docker stop redis-node6
1

docker start redis-node6
1

步骤四：查看集群状态

redis- cli --cluster check 192.168.21.130:6381
1

主从容扩案例

步骤一：新建6387、6388两个节点+新建后启动+查看是否8个节点

docker run -d --name redis-node7 --net host --privileged=true -v /data/redis/share/redis-node-7:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6387
1

docker run -d --name redis-node8 --net host --privileged=true -v /data/redis/share/redis-node-8:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6388
1

步骤二：进入6387容器实例内部

docker exec -it redis-node7 /bin/bash
1

步骤三：将新增的6387节点（空槽号）作为master节点加入原集群

6381就是原来集群节点里面的领路人，相当于6387找到6381从而找到组织加入集群

redis-cli --cluster add-node 192.168.21.130:6387 192.168.21.130:6381
1

步骤四：检查集群情况第一次

redis-cli --cluster check 192.168.21.130:6381
1

步骤五：重新分派槽号

redis-cli --cluster reshard 192.168.21.130:6381
1

注：

• How many slots do you want to move(from 1 to 16384)?
  4098
  执行后将从其它ip槽中分配出前部分槽，总计4089个slots给接收的ID

• what is the receiving node ID?
  需要接收的Redis ID

步骤六：检查集群情况第二次

redis-cli --cluster check 192.168.21.130:6381
1

步骤七：为主节点6387分配从节点6388

命令：redis- cli --cluster add-node ip:新的slave端口号 ip:新的master端口号 --cluster-slave --cluster-master-id 新主机节点ID

redis-cli --cluster add-node 192.168.21.130:6388 192.168.21.130:6387 --cluster-slave --cluster-master-id 6378的ID
1

步骤八：检查集群情况第三次

redis-cli --cluster check 192.168.21.130:6382
1

redis-cli -p 6381 -c
cluster nodes
1
2

主从缩容案例

目的：下线6387和6388

步骤分析：1、先清除从节点6388 2、清出来的槽号重新分配 3、在删除6387 4、恢复3主3从

步骤一：检查集群情况1获得6388的节点ID

redis-cli --cluster check 192.168.21.130:6383
1

步骤二：从集群中将节点6388删除

redis-cli --cluster del-node 192.168.21.130:6388 6388的ID
1

步骤三：将6387的槽号清空，重新分配，本例将清出来的槽号给6381

redis-cli --cluster reshard 192.168.21.130:6381
1

注：

• How many slots do you want to move(from 1 to 16384)?
  4098
  执行后将从其它ip槽中分配出前部分槽，总计4089个slots给接收的6381的ID

• what is the receiving node ID?
  需要接收的6381的ID

• Source node #1: 6387的节点，告知删除哪个

步骤四：检查集群情况第二次

redis-cli --cluster check 192.168.21.130:6383
1

步骤五：将6387删除

redis-cli --cluster del-node 192.168.21.130:6387 6387的ID
1

步骤六：检查集群情况第三次

redis-cli --cluster check 192.168.21.130:6383
1

DockerFile解析

官网参考：https://docs.docker.com/engine/reference/builder/

是什么

Dockerfile是用来构建Docker镜像的文本文件，是由一条条构建镜像所需的指令和参数构成的脚本，内容包括：执行代码、执行文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行版、服务进程和内核进程等等。在用Dockerfile定义了一个文件后，docker build时会产生一个Docker镜像，当运行Docker镜像时会真正开始提供服务，由Docker镜像生成Docker容器，Docker容器再直接提供服务。

构建三步骤：编写Dockerfile文件—>docker build命令构建镜像—>docker run 镜像运行容器实例

构建过程解析

Dockerfile内容编写规则：

1. 每条保留字指令都必须为大写字母且后面要跟随至少一个参数
2. 指令按从上到下，顺序执行
3. #表示注释
4. 每条指令都会创建一个新的镜像层并对镜像进行提交

Docker执行Dockerfile的大致流程大致分为以下几个步骤：

1. docker从基础镜像运行一个容器
2. 执行一条指令并对容器作出修改
3. 执行类似docker commit的操作提交一个新的镜像层
4. docker再基于刚提交的镜像运行一个新容器
5. 执行dockerfile中的下一条指令直到所有指令都执行完成

常用保留字指令

Dockerfile中通过各种保留字，决定指令执行的动作。可参考tomcat6的dockerfile入门：https://github.com/docker-library/tomcat

• FROM

  基础镜像，当前新镜像是基于哪个镜像的，指定一个已经存在的镜像作为模板，第一条必须是from

• MAINTAINER

  镜像维护者的姓名和邮箱地址

• RUN

  容器构建时需要运行的命令，在docker build时运行，具有两种格式：

  1、shell格式：RUN <命令行命令>

  注：<命令行命令>等同于在终端操作的shell命令

  2、exec格式：RUN [“可执行文件”,“参数1”,“参数2”]

  注：RUN [“./test.php”,“dev”,“offline”] 等价于 RUN ./test.php dev offline

• EXPOSE

  当前容器对外暴露的端口

• WORKDIR

  指定在创建容器后，终端默认登陆的进来工作目录，一个落脚点

• USER

  指定该镜像以什么样的用户去执行，如果都不指定，默认是root

• ENV

  用来在镜像环境过程中设置环境变量
  ENV MY_PATH /usr/mytest
  这个环境变量可以在后续的任何RUN指令中使用，也可以在其他指令中直接使用这些环境变量
  example：WORKDIR $MY_PATH

  

• ADD

  将宿主机目录下的文件拷贝进镜像且会自动处理URL和解压tar压缩包

• COPY

  类似于ADD，拷贝文件和目录到镜像中。将从构建上下文目录中<源路径>的文件/目录复制到新的一层的镜像内的<目标路径>位置

  命令：COPY src dest 或者 COPY [“src”,“dest”]

  注：: 源文件或者源目录，: 容器内的指定路径，该路径不用事先建好

• VOLUME

  容器数据卷，用于数据保存和持久化工作

• CMD

  指定容器启动后要干的事

  两种格式:

  • shell 格式：CMD<命令>

  • exec格式：CMD[“可执行文件”,“参数1”,“参数2”…]

    1. 参数列表格式：CMD [“参数1”,“参数2”…]，在指定了 ENTRYPOINT指令后，用CMD指定具体的参数
    2. Dockerfile中可以有多个CMD指令，但只有最后一个生效，CMD会被docker run 之后的参数替换

    可参考官网Tomcat的dockerfile演示，官网最后一行命令： CMD [“catalina.sh”,“run”]，下载tomcat镜像并run一个容器实例，再执行以下 覆盖操作：

  docker run -it -p 8080:8080 tomcat容器实例的ID /bin/bash
  1

  与RUN的区别：CMD是在docker run时运行，RUN是在docker build时运行

  

• ENTRYPOINT

  用来指定有个容器启动时要运行的命令。类似于CMD命令，但是ENTRYPOINT不会被docker run后面的命令覆盖，而且这些命令行参数会被当作参数送给ENTRYPOINT指定的程序

  命令格式：ENTRYPOINT [“”,“”,“”,…]

  注：ENTRYPOINT可以和CMD一起使用，一般是变参才会使用CMD，这里的CMD等于是在给ENTRYPOINT传参。
  当指定了ENTRYPOINT后，CMD的含义就发生了变化，不再是直接运行其命令而是将CMD的内容作为参数传递给ENTRYPOINT指令，组合会变成 “”"

  example：(已通过Dockerfile构建了nginx:test镜像

  FROM nginx
  ENTRYPOINT ["nginx","-c"]  #定参
  CMD ["/etc/nginx/nginx.conf"] #变参
  1
  2
  3

案例1：自定义镜像mycentosjava8 （问题案例）

要求：Centos镜像具备vim_ifconfig+jdk8

jdk下载镜像地址：

官网：https://www.oracle.com/java/technologies/downloads/#java8
x64 Compressed Archive 138.78MB jdk-8u301-linux-x64.tar.gz

国内：https://mirrors.yangxinzhen.com/jdk/

步骤一：宿主机下编写Dockerfile

mkdir /myfile
1

vim Dockerfile:
FROM centos:7
MAINTAINER lyx<lyx@qq.com>

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 glib.i686
RUN mkdir /usr/local/java
# ADD 是相对路径 jar.把jdk-8u301-linux-x64.tar.gz添加到容器中，安装包必须要和Dockerfile文件在同一位置
ADD jdk-8u301-linux-x64.tar.gz /usr/local/java/
#配置 java环境变量
ENV JAVA_HOME /usr/local/java/jdk1.8.0_301
ENV JRE_HOME $JAVA_HOME/jre
ENV CLASSPATH $JAVA_HOME/lib/dt.jar;$JAVA_HOME/lib/tools.jar;$JAVA_HOME/lib;$CLASSPATH
ENV PATH #JAVA_HOME/bin:$PATH

EXPOSE 80

CMD echo $MYPATH
CMD echo 'success......ok'
CMD /bin/bash


1
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

将jdk安装包与Dockerfile存放在同一路径下

步骤二：构建

docker build -t centosjava8:1.5 .
1

注意，上面TAG后面有个空格，有个点

问题：运行 RUN yum -y install vim 时报错 Error: Failed to download metadata for repo ‘appstream’: Cannot prepare internal mirrorlist: No URLs in mirrorlist

原因：Centos8于2021年年底停止了服务，

解决：将 FROM centos:7 改为 centos:7.9.2009

继续出现问题：Package does not match intended download. Suggestion: run yum --enablerepo=base clean metadata Trying other mirror

原因：安装包的版本不符

解决：暂时没发现解决办法

步骤三：运行

docker run -it centosjava8:1.5
1

案例2：自定义镜像myubuntu

步骤一：编写Dockerfile文件

FROM ubuntu
MAINTAINER lyx<lyx@qq.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH

RUN apt-get update
RUN apt-get install net-tools


EXPOSE 80
1
2
3
4
5
6
7
8
9
10
11

步骤二：构建

docker build -t 新镜像名字:TAG . 
1

步骤三：运行

docker run -it 新镜像名字:TAG
1

关于虚悬镜像

虚悬镜像是一种仓库名、标签都是的镜像，俗称dangling image

查看命令：

docker image ls -f dangling=true
1

删除命令：

docker image prune
1

实例：

步骤一：创建一个虚悬镜像

编写一个Dockerfile文件：

vim Dockerfile

from ubuntu
CMD echo 'action is success'
1
2
3
4

docker build .
1

docker images
1

步骤二：查看

步骤三：删除

微服务实战

步骤一：通过IDEA新建一个普通微服务模块，微服务，运行，形成jar包，将jar包上传到linux虚拟机上

步骤二：通过dockerfile发布微服务部署到docker容器

1、编写Dockerfile，将微服务jar包和Dockerfile文件上传到同一个目录下/mydocker

touch Dockerfile
1

vim Dockerfile
1

# 基础镜像使用java
FROM java:8
# 作者
MAINTAINER lyx
# VLOUME 指定临时文件目录为/tmp，在主机/var/lib/docker目录下创建了一个临时文件并链接到容器的/tmp
VOLUME /tmp
# 将jar包添加到容器中并更名为lyx_docker.jar
ADD docker_boot-0.0.1-SNAPSHOT.jar lyx_docker.jar
# 运行jar包
RUN bash -c 'touch /lyx_docker.jar'
ENTRYPOINT ["java“,".jar","/lyx_docker.jar"]
# 暴露6001端口作为微服务
EXPOSE 6001
1
2
3
4
5
6
7
8
9
10
11
12
13

2、构建镜像

docker build -t lyx_docker:1.6 .
1

3、查看微服务是否成功部署

docker images
1

4、关闭防火墙，重启docker

systemctl stop firewalld
1

systemctl restart docker
1

5、运行容器，检查状态

docker run -d -p 6001:6001 lyx_docker:1.6
1

curl ip/请求URL
1

6、访问测试

网络

是什么

我们可以查看下，docker不启动，默认网络情况：

ip addr
1

• ens33：主机网络
• lo：回环网卡，完全由软件实现的一种不予任何实际设备连接的特殊网络接口，任何发送到该网卡上的数据将立刻被同一网卡接收到
• virbr0：
  在CentOS7的安装过程中如果有选择相关虚拟化的服务安装系统后（勾选了libvirt服务），启动网卡时会发现有一个以网络连接的私网地址的virbr0网卡（固定的默认IP地址：192.168.122.1），是做虚拟机网桥的使用的，其作用是为连接其上的虚拟网卡提供NAT访问外网的功能。
  卸载libvirtd服务：
  yum remove libvirt-libs.x86_64

docker启动后，网络产生一个名为docker0的虚拟网桥：

 ip addr
1

查看docker网络模式：

docker network ls
1

默认创建3大网络模式：bridge、host、none

能干嘛

实例：

docker run -it --name u1 ubuntu bash
ctrl+p+q
docker run -it --name u2 ubuntu bash
ctrl+p+q
docker ps
docker inspect u1 | tail -n 20
docker inspect u2 | tail -n 20
docker stop u1
docker  stop u2
docker start u2
docker start u1
docker inspect u1 | tail -n 20
docker inspect u2 | tail -n 20
1
2
3
4
5
6
7
8
9
10
11
12
13

docker 容器内部的ip是有可能会发生改变的，因此，使用各种网络模式可以：

1. 容器间的互联和通信以及端口映射
2. 容器IP变动时候可以通过服务名直接网络通信而不受影响

常用基本命令

• 查看network的用法

  docker network --help
  1

• 查看网络

  docker network ls
  1

• 查看网络源数据

  docker network inspect ***网络名字
  1

• 自定义一个网络

  docker network create ***网络名字
  1

• 内联网络

  docker network connect ***网络名字
  1

• 删除网络

  docker network rm ***网络名字
  1

• 删除所有未在使用的网络

  docker network prune ***网络名字
  1

网络模式

bridge(默认网络连接方式)

采用bridge网络模式连接会为每一个容器分配、设置IP等，并将容器连接到一个docker0虚拟网桥，docker0网桥是Docker服务器默认创建的，其上有一个docker0内部接口，它在内核层连通了其它的物理或虚拟网卡，这就将所有容器和本地主机都放到同一个物理网络。Docker默认指定了docker0接口的IP和子网掩码，让主机和容器之间可以通过网桥相互通信。此外，Docker启动一个容器时会根据Docker网桥的网段分配给容器一个IP地址，称为Container-IP，同时Docker网桥是每个容器的默认网关。因为在同一宿主机内的容器都接入同一个网桥，这样容器之间就能够通过容器的Container-IP直接通信。

网桥docker0会创建一对对等虚拟设备接口，一个叫veth，一个叫eth0，成对匹配。在整个宿主机内，网桥模式都是docker0，类似一个交换机有一堆接口，每个接口都叫veth，在本地主机和容器内分别创建一个虚拟接口，并让他们彼此相同（这样一堆接口叫veth pair），每个容器实例内部都存在一块网卡，每个接口都叫eth0

指定方式：使用–network bridge指定，默认使用docker0

相关命令：# 查看bridge网络的详细信息，并通过grep获取名称项

docker network inspect bridge | grep name
ifconfig | grep docker
1
2

example：

docker run -d -p 8081:8080 --name tomcat01 billygoo/tomcat8-jdk8
1

docker run -d -p 8082:8080 --name tomcat02 billygoo/tomcat8-jdk8
1

匹配验证

ip addr | tail -n 8
1

docker exec -it tomcat01 bash
docker exec -it tomcat02 bash
1
2

host

容器将不会虚拟出自己的网卡，配置自己的IP，也不会获得一个独立的Network Namespace等，而是直接使用宿主机的IP和端口，与外界进行通信，不再需要额外进行NAT转换

指定方式：使用–network host指定

相关命令：

docker network inspect host
1

example：

docker run -d -p 8083:8080 --network host --name tomcat03 billygoo/tomcat8-jdk8
1

出现警告

• 原因：docker启动时指定–network=host或-net=host，还指定了-p映射端口（此时-p指定参数不起作用，默认使用host的端口号）

• 解决：将host网络模式换成其它网络模式，或者直接无视警告

正确方式

docker run -d  --network host --name tomcat03 billygoo/tomcat8-jdk8
1

结论：容器实例内部无新增之前的类似配对显示了，而是和主机共用相同的

none

容器有独立的Network namespace，但并没有对其进行任何网络设置，如分配 veth pair 和网桥连接，IP、路由等信息。相当于是禁用网络功能，只有lo标识（127.0.0.1表示本地回环），需要手动为Docker容器添加网卡、配置IP等

指定方式：使用–network none指定

相关命令：

docker network inspect none
1

example:

docker run -d -p 8084:8080 --network none --name tomcat04 billygoo/tomcat8-jdk8
1

container

新创建的容器不会创建自己的网卡和配置自己的IP，而是和一个指定的已经存在的容器共享IP，端口范围等。两个容器除了网络方面，其他的如文件系统、进程列表等还是隔离的。

指定方式：使用–network container:NAME或者容器ID指定

相关命令：

docker network inspect container
1

example：使用轻型Linux发行版Alpine操作系统举例

docker run -it --name alpine01 alpine /bin/sh
1

docker run -it --network container:alpine1 --name alpine02 alpine /bin/sh
1

运行结果，验证共用搭桥:

假如此时关闭alpine01，alpine02也将断开网络:

自定义网络

自定义桥接网络，自定义网络默认使用的是桥接网络bridge，可指定其他网络

相关命令：

docker network inspect 自定义网络名称
1

example01：

docker run -d -p 8081:8080 --name tomcat81 billygoo/tomcat8-jdk
1

docker run -d -p 8082:8080 --name tomcat81 billygoo/tomcat8-jdk
1

成功启动后用docker exec进入各自容器实例内部

在8081端口机上ping8082机：

ip addr
ping 8082机上的ip
ping 8082机名
1
2
3

在8082端口机上ping8081机：

ip addr
ping 8081机上的ip
ping 8081机名
1
2
3

结论：按照IP地址互ping，可成功；按照服务名ping，出现：Name or service not known

解决：自定义网络，看example02

example02：

新建自定义网络

docker network ls
docker network create lyx_network
docker network ls
1
2
3

移除tomcat01和tomcat02容器，并新建容器加入上一步新建的自定义网络

docker rm -f tomcat01
docker rm -f tomcat02
1
2

docker run -d -p 8081:8080 --network lyx_network --name tomcat01 billygoo\tomcat8-jdk8 
1

docker run -d -p 8082:8080 --network lyx_network --name tomcat02 billygoo/tomcat8-jdk8 
1

再次互ping

结论：自定义网络本身就维护好了主机名和ip的对应关系（ip和域名都能通）

Docker-compose容器编排

是什么

Docker-Compose是Docker官方的开源项目，负责实现对Docker容器集群的快速编排，可以管理多个Docker容器组成一个应用。需要定义一个YAML格式的配置文件docker-compose.yml，写好多个容器之间的调用关系，然后只要一个命令，就能同时启动/关闭这些容器

能干嘛

按照以往直接一个一个调用容器问题：

1、容器启动的顺序要求固定

2、需要运行多个run命令

3、容器之间出现启停或宕机，有可能导致IP地址对应的容器实例变化，映射出错，要么生产IP写死（不推荐），要么通过服务调用

采用Compose编排技术，可以通过一个单独的docker-compose.yml模板文件来定义一组相关联的应用容器作为一个项目，容后通过一条指令安装这个应用的所有依赖，完成构建

安装下载

官网介绍：https://docs.docker.com/compose/comp

官网安装下载：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
1

chmod +x /usr/local/bin/docker-compose
1

docker-compose --version
1

卸载步骤：

rm /usr/local/bin/docker-compose
1

常用命令

查看帮助：

docker-compose -h
1

启动所有docker-compose服务：

docker-compose up
1

启动所有docker-compose服务并后台运行：

docker-compose up -d
1

停止并删除容器、网络、卷、镜像：

docker-compose down
1

进入容器实例内部 docker-compose exec docker-compose.yml文件中写的服务id /bin/bash ：

docker-compose exec yml里面的服务id
1

展示当前docker-compose编排过的运行的所有容器：

docker-compose ps
1

展示当前docker-compose编排过的容器进程：

docker-compose top
1

查看容器输出日志：

docker-compose logs yml里面的服务id
1

检查配置：

docker-compose config
1

检查配置，有问题才输出：

docker-compose config -q
1

重启服务：

docker-compose restart
1

启动服务：

docker-compose start
1

停止服务：

docker-compose stop
1

Compose编排服务

使用的三大步骤：

1. 编写Dockerfile定义各个微服务应用并构建出对应的镜像文件

2. 使用docker-compose.yml定义一个完整业务单元，安排好整体应用中的各个容器服务

3. 执行docker-compose up命令来启动并运行整个应用程序，完成一键部署上线

example:

步骤一：mvn package命令将微服务形成新的jar包，并上传到Linux服务器/mydocker目录下

步骤二：编写Dockerfile各个微服务应用并构建出对应的镜像文件

# 基础镜像使用java
FROM java:8
# 作者
MAINTAINER lyx
# VOLUME 指定临时文件目录为/tmp，在主机/var/lib/docker目录下创建一个临时文件并链接到容器的/tmp
VOLUME /tmp
# 将jar包添加到容器中并更名为lyx_docker.jar
ADD docker_boot-0.0.1-SNAPSHOT.jar
# 运行jar包
RUN bash -c 'touch /lyz_docker.jar'
ENTRYPOUNT ["java","-jar","/lyx_docker.jar"]
# 暴露6001端口作为微服务
EXPOSE 6001
1
2
3
4
5
6
7
8
9
10
11
12
13

docker build -t lyx_docker:1.6 .
1

步骤三：编写docker-compose.yml文件

version: "3"

services:
   microService:
     image: lyx_docker: 1.6
     container_name: ms01
     ports:
       - "6001:6001"
     volumes:
       - /app/microService:/data
     networks:
       - atguigu_net
     depends_on:
       - redis
       - mysql
    redis:
     image: redis:6.0.8
     ports:
       - "6379:6379"
     volume:
       - /app/redis/redis.conf:/etc/redis/redis.conf
       - /app/redis/data:/data
     networks:
       - atguigu_net
     command: redis-server /etc/redis/redis.conf
    mysql:
       image: mysql:5.7
       environment:
          MYSQL_ROOT_PASSWORD: '123456'
          MYSQL_ALLOW_EMPTY_PASSWORD: 'no'
          MYSQL_DATABASE: 'db2021'
          MYSQL_USER: 'lyx'
          MYSQL_PASSWORD: 'lyx123'
       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:
          - atguigu_net
       # 解决外部无法访问
       command: --default-authentication-plugin=mysql_native_password 
   networks:
       atguigu_net:
 
1
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
37
38
39
40
41
42
43
44
45
46

步骤四：执行Compose启动命令

docker-compose up -d
1

测试：进入mysql容器实例并新建库db2021+新建表t_user

轻量级 可视化工具Portainer

是什么

Portainer 是一款轻量级的应用，它提供了图形化界面，用于方便地管理Docker环境，包括单机环境和集群环境

安装

官网：https://docs.portainer.io/v/ce-2.9/start/install/server/docker/linux

安装步骤：

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
1

第一次登录需创建admin，访问地址： ...:9000，设置admin用户和密码后首次登陆

选择local选项卡后本地docker详细信息展示

上一步的图形展示对应的命令：

docker system df
1

点击connect：

使用

查看本地容器卷、栈、镜像、容器、网络

可通过可视化按钮，点击start、stop、kill、restart、Remove、Add container等对容器进行相关操作，相当于执行了相关容器命令

可通过可视化按钮对镜像进行相关操作

可通过可视化按钮对网络进行相关操作

可视化按钮对容器卷进行相关操作

查看操作容器日志

容器监控 CAdvisor+InfluxDB+Granfana

原生docker查看容器资源使用命令：

docker ps
docker stats
1
2

存在的问题：

统计结果只能是当前宿主机的全部容器，数据资料是实时的，没有地方存储、没有健康指标、过线预警等功能

引用的解决方案：引入CAdvisor+InfluxDB+Granfana组合进行容器监控

是什么

cAdvisor将数据存储到InfluxDB，Grafana从InfluxDB中拿到数据进行分析，将数据展示在web端界面

CAdvisor

一个容器资源监控工具，包括容器的内存，cpu，网络IO，磁盘IO等监控，同时提供了一个WEB页面用于查看容器的实时运行状态。CAdvisor默认存储2分钟的数据，而且只是针对单物理机。CAdvisor提供了很多数据集成接口，支持InfluxDB，Redis，Kafka，Elasticsearch等集成，可以加上对应配置将监控数据发往这些数据库存储：
1、展示Host和容器两个层次的监控数据
2、展示历史变化数据

InfluxDB

用Go语言编写的一个开源分布式时序、事件和指标数据库，无需外部依赖。CAdvisor默认只在本机保存最近2分钟的数据，为了持久化存储数据和统一收集展示监控数据，需要将数据存储到InfluxDB中。InfluxDB是一个时序数据库，专门用于存储时序相关数据，很适合存储CAdvisor的数据。而且，CAdvisor本身已经提供了InfluxDB的集成方法，启动容器时指定配置即可：
1、基于时间序列，支持与时间有关的相关函数（如最大、最小、求和等）
2、可度量：实时对大量数据进行计算
3、基于事件：它支持任意的事件数据

Granfana

是一个开源的数据监控分析可视化平台，支持多种数据源配置（支持的数据源包括InfluxDB，MySQL，Elasticsearch，OpenTSDB，Graphite等）和丰富的插件及模板功能吗，支持图表权限控制和报警：
1、灵活丰富的图形选项
2、可以混合多种风格
3、支持白天和夜间模式
4、多个数据源

使用

步骤一：新建目录

mkdir /mydocker/cig
1

步骤二：新建3件套组合的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=cadvidsor -storage_driver_host=influxsrv:8086
  restart: always
  ports:
   - "8080:8080"
  volume:
   - /:/rootfs:ro
   - /var/run:/var/run:rw
   - /sys:/sys:ro
   - /var/lib/docker/:/var/lib/docker:ro
 
 grafana:
  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=cadvidsor
   - INFLUXDB_USER=root
   - INFLUXDB_PASS=root
1
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
37
38
39
40
41
42
43
44
45
46
47
48

步骤三：启动docker-compose文件

docker-compose up
1

步骤四：查看三个服务容器是否启动

• 浏览cAdvisor收集服务，http://ip:8080/

• 浏览influxdb存储服务，http://ip:8083/

• 浏览器grafana展现服务，http://ip:3000

  • ip+3000端口的方式访问，默认账户密码（admin/admin)

  • 配置步骤

    1. 配置数据源

    2. 选择influxdb数据源

    3. 配置细节：

       Name：InfluxDB

       URL：http://InfluxDB:8086

       Database: cadvisor

       User: root

    4. 配置面板panel

       Create Dashboard
       Add an empty panel
       Search for: Graph
       Edit
       FROM cpu_usage_total WHERE container_name=cig_cadvisor_1