Docker学习

基础篇

---

一、Docker的简介

        是什么

                Docker的出现使得Docker得以打破过去「程序即应用」的观念。透过镜像(images)将作业系统核心除外，运作应用程式所需要的系统环境，由下而上打包，达到应用程式跨平台间的无缝接轨运作。解决了运行环境和配置问题的的软件容器

                Docker之所以发展如此迅速，也是因为它对此给出了一个标准化的解决方案-----系统平滑移植，容器虚拟化技术。安装的时候，把原始环境一模一样地复制过来。开发人员利用 Docker 可以消除协作编码时“在我的机器上可正常工作”的问题。方便做持续集成并整体发布的容器虚拟化技术。

Docker是基于Go语言实现的云开源项目。

                实现过程：将应用打成镜像，通过镜像成为运行在Docker容器上面的实例，而 Docker容器在任何操作系统上都是一致的，这就实现了跨平台、跨服务器。“一处镜像，处处执行”

         虚拟机和容器比较

                传统虚拟机技术基于安装在主操作系统上的虚拟机管理系统(如: VirtualBox 和VMWare等)， 创建虚拟机(虚拟出各种硬件)，在虚拟机上安装从操作系统，在从操作系统中安装部署各种应用。虚拟机的缺点：1    资源占用多               2    冗余步骤多                 3    启动慢

                Docker容器是在操作系统层面上实现虚拟化，直接复用本地主机的操作系统，而传统虚拟机则是在硬件层面实现虚拟化。与传统的虚拟机相比，Docker 优势体现为启动速度快、占用体积小。

                比较了 Docker 和传统虚拟化方式的不同之处：

                *传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上再运行所需应用进程；

                *容器内的应用进程直接运行于宿主的内核，容器内没有自己的内核且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便。

        * 每个容器之间互相隔离，每个容器有自己的文件系统 ，容器之间进程不会相互影响，能区分计算资源。

        去哪下

                官网：http://www.docker.com        仓库： https://hub.docker.com

二、docker的安装

        docker的基本组成

                镜像、容器、仓库

                Docker 镜像（Image）就是一个只读的模板。镜像可以用来创建 Docker 容器，一个镜像可以创建很多容器。

                容器（Container）是用镜像创建的运行实例。可以把容器看做是一个简易版的 Linux 环境

                仓库（Repository）是集中存放镜像文件的场所。

        centOS7安装Docker

                Install Docker Engine on CentOS | Docker Documentation

                安装步骤

                        确定是centOS7版本以上

                                cat /etc/redhat-release

                        1.卸载旧版本Docker

                         2.yum安装gcc相关

        yum -y install gcc

        yum -y install gcc-c++

                        3.安装需要的软件包 

        yum install -y yum-utils

                         4.设置stable镜像仓库

        使用国内的阿里云镜像仓库

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

                         5.更新yum软件包索引

        yum makecache fast

                        6.安装DOCKER CE 

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

                        7.启动Docker 

systemctl start docker

                        8.测试

docker version

docker run hello-world

                        9.卸载Docker 

systemctl stop docker

yum remove docker-ce docker-ce-cli containerd.io

rm -rf/var/lib/docker

rm -rf/var/lib/containerd

        阿里云镜像加速

                是什么：开放云原生应用-云原生（Cloud Native）-云原生介绍 - 阿里云

                注册账号-->打开容器镜像服务-->镜像加速器-->复制地址

                2. 配置镜像加速器

                        针对Docker客户端版本大于 1.10.0 的用户

                        您可以通过修改daemon配置文件/etc/docker/daemon.json来使用加速器

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["加速器地址"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

        run干了什么

         底层原理

                (1)docker有着比虚拟机更少的抽象层 

                (2)docker利用的是宿主机的内核,而不需要加载操作系统OS内核

三、Docker常用命令

        帮助启动类命令

                

        镜像命令

1.        docker images        #列出主机本地镜像

docker images -a        # -a 列出本地所有镜像（包含历史映像层） -q: 只显示镜像ID

        REPOSITORY：表示镜像的仓库源

        TAG：镜像的标签版本号

        IMAGE ID：镜像ID

        CREATED：镜像创建时间

        SIZE：镜像大小

2.        docker search  某个镜像名字      #在仓库中查询镜像

docker search redis --limit 5        #limit 默认25个

 3.        docker pull 某个镜像名称 [:TAG]        #没有tag，就是下载最新版

        docker pull mysql :5.6

4.        docker system df        #查看镜像/容器/数据卷所占空间        类似与Linux命令 df -h

5.        docker rmi 某个镜像名字ID        #删除镜像

docker rmi a || docker rmi -f a

        docker rmi -f ID        #强制删除单个

docker rmi -f 12912

        docker rmi -f 镜像名1:TAG 镜像名2:TAG        #删除多个

docker rmi -f a b c

        docker rmi -f $(docker images -qa)        #删除全部(组合使用)

        面试题 ：谈谈docker虚悬镜像是什么？

是什么？

        仓库名、标签都是<none>的镜像，俗称        虚悬镜像（dangling image）

长什么样？

                建议删除

         容器命令

                有镜像才能创建容器

        使用ubuntu演示

        新建+启动容器

         docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

        如：docker run -it --name=myu1 ubuntu:latest /bin/bash

        OPTIONS说明

         

         启动交互式容器（前台命令行）

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

docker ps [OPTIONS]

 退出容器

exit  #run进去容器，exit 退出， 容器停止

ctrl + p + q        #run进去容器, ctrl +p + q 退出， 容器不停止

启动已经停止的容器、重启容器、停止容器 、强制停止容器

docker start 容器ID或容器名        #启动已经停止的容器

删除容器

docker rm 容器ID和name        #加上 -f 强制删除

 

 启动守护式容器（后台服务器）

查看容器日志、查看容器内运行进程、查看容器内部细节 

 

进入正在运行的容器里进行交互 

docker exec -it 容器ID bashShell

如：docker exec -it 61290347fa51 bash

docker attach 容器ID

如：docker attach 61290347fa51

从容器拷贝文件到主机 

导入导出容器

 

命令总结

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   # 截取容器停止时的退出状态值

 四、Docker镜像

        是什么 

        镜像

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

        只有通过这个镜像文件才能生成Docker容器实例(类似Java中new出来一个对象)。

        分层的镜像：以我们的pull为例，在下载的过程中我们可以看到docker的镜像好像是在一层一层的在下载。

        UnionFS（联合文件系统）：Union文件系统（UnionFS）是一种分层、轻量级并且高性能、聚合的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。Union 文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。

特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录

        镜像加载原理

        bootfs(boot file system)主要包含bootloader和kernel, bootloader主要是引导加载kernel, Linux刚启动时会加载bootfs文件系统，在Docker镜像的最底层是引导文件系统bootfs。这一层与我们典型的Linux/Unix系统是一样的，包含boot加载器和内核。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。

rootfs (root file system) ，在bootfs之上。包含的就是典型 Linux 系统中的 /dev, /proc, /bin, /etc 等标准目录和文件。rootfs就是各种不同的操作系统发行版，比如Ubuntu，Centos等等。 

精简：Linux启动时，加载bootfs里面的两个工具：加载器和内核；bootloader主要用来加载kernel(内核),加载完后，内存使用权交给内核，卸载bootfs。Docker提供rootfs，在内核之上运行

        对于一个精简的OS，rootfs可以很小，只需要包括最基本的命令、工具和程序库就可以了，因为底层直接用Host的kernel，自己只需要提供 rootfs 就行了。由此可见对于不同的linux发行版, bootfs基本是一致的, rootfs会有差别, 因此不同的发行版可以公用bootfs。

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

        重点：当容器启动时，一个新的可写层被加载到镜像的顶部。这一层通常被称作“容器层”，“容器层”之下的都叫“镜像层”。

所有对容器的改动 - 无论添加、删除、还是修改文件都只会发生在容器层中。只有容器层是可写的，容器层下面的所有镜像层都是只读的。

Dokcer镜像Commit操作 

docker commit -m="ifconfig add ok" -a="zzbb" 285a487534d7 zzbbubuntu:1.1

 

总结

五、本地镜像发布阿里云

         www.aliyun.com

六、本地镜像发布私有库

        1.下载Docker Registry

docker pull registry 

        2.运行私有库Registry,相当于本地有个私有Docker Hub

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

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

         3.curl验证私有库有什么镜像

 curl -XGET http://主机IP:5000/v2/_catalog

        4.修改Tag

        按照公式： docker   tag   镜像:Tag   Host:Port/Repository:Tag

        使用命令 docker tag 将zzbbubuntu:1.1 这个镜像修改为192.168.8.100:5000/zzbbubuntu:1.1

        docker tag zzbbubuntu:1.1 192.168.8.100:5000/zzbbubuntu:1.1

         5.修改配置文件支持Http推送

上述理由：docker默认不允许http方式推送镜像，通过配置选项来取消这个限制。====> 修改完后如果不生效，建议重启docker

         6.push推送私有库

docker push 192.168.8.100:5000/zzyyubuntu:1.1

        7.pull拉取私有库

docker pull 192.168.111.162:5000/zzyyubuntu:1.2

七、Docker 容器数据卷

        是什么

持久化

        数据卷案例

        宿主与容器之间映射添加数据卷

公式：docker run -it -v /宿主机目录:/容器内目录 ubuntu /bin/bash
如：docker run -it --name myu3 --privileged=true -v /tmp/myHostData:/tmp/myDockerData ubuntu /bin/bash

特点：

        1：数据卷可在容器之间共享或重用数据

        2：卷中的更改可以直接实时生效，爽

        3：数据卷中的更改不会包含在镜像的更新中

        4：数据卷的生命周期一直持续到没有容器使用它为止

docker inspect 容器ID #查看数据卷挂载是否成功

         双向连接

1  docker修改，主机同步获得 

2 主机修改，docker同步获得

3 docker容器stop，主机修改，docker容器重启看数据同步。

        容器只读（默认读写）

docker run -it -v /宿主机目录:/容器内目录:ro ubuntu /bin/bash
如：docker run -it -v /tmp/myHostData:/tem/myDcokerData:ro ubuntu /bin/bash

        卷的继承和共享

docker run -it --privileged=true --volumes-from 父类 --name 别名 ubuntu
如：docker run -it --privileged=true --volumes-from u1 --name u2 ubuntu

八、Docker常规安装(一定要装载数据卷)

        安装Tomcat

docker run -d -p 8080:8080 --name myTomcat8 billygoo/tomcat8-jdk8

        Tomcat最新版 访问 localhost:8080 访问不了

        解决方法：把webapps删掉，将webapps.dist改名为webapps

         安装mysql

docker pull mysql:5.7
#使用镜像
docker run -d -p 3306:3306 --privileged=true -v /zzbbuse/mysql/log:/var/log/mysql -v /zzbbuse/mysql/data:/var/lib/mysql -v /zzbbuse/mysql/conf:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=123456  --name mysql mysql:5.7

#登录
mysql -uroot -p

        不能插入中文

SHOW VARIABLES LIKE 'character%'    #查看Docker mysql数据库字符集

         解决办法 新建my.cnf

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

         安装Redis

 

docker run  -p 6379:6379 --name myredis--privileged=true -v /app/redis/redis.conf:/etc/redis/redis.conf -v /app/redis/data:/data -d redis redis-server /etc/redis/redis.conf
#使用redis镜像创建容器

高级篇

---

一、Docker复杂安装

        Mysql复杂安装

        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=123456 -d mysql:5.7

        2.进入主机/mydata/mysql-master/conf目录新建my.cnf

[mysqld]
## 设置server_id，同一局域网中需要唯一
server_id=101
## 指定不需要同步的数据库名称
binlog-ignore-db=mysql
## 开启二进制日志功能
log-bin=mall-mysql-bin
## 设置二进制日志使用内存大小（事务）
binlog_cache_size=1M
## 设置使用的二进制日志格式（mixed,statement,row）
binlog_format=mixed
## 二进制日志过期清理时间。默认值为0，表示不自动清理。
expire_logs_days=7
## 跳过主从复制中遇到的所有错误或指定类型的错误，避免slave端复制中断。
## 如：1062错误是指一些主键重复，1032错误是因为主从数据库数据不一致
slave_skip_errors=1062

        3.重启mysql

        4.进入容器

        

         1.新建服务器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=123456 -d mysql:5.7

        2.进入主机/mydata/mysql-salve/conf目录新建my.cnf

[mysqld]
## 设置server_id，同一局域网中需要唯一
server_id=102
## 指定不需要同步的数据库名称
binlog-ignore-db=mysql
## 开启二进制日志功能，以备Slave作为其它数据库实例的Master时使用
log-bin=mall-mysql-slave1-bin
## 设置二进制日志使用内存大小（事务）
binlog_cache_size=1M
## 设置使用的二进制日志格式（mixed,statement,row）
binlog_format=mixed
## 二进制日志过期清理时间。默认值为0，表示不自动清理。
expire_logs_days=7
## 跳过主从复制中遇到的所有错误或指定类型的错误，避免slave端复制中断。
## 如：1062错误是指一些主键重复，1032错误是因为主从数据库数据不一致
slave_skip_errors=1062
## relay_log配置中继日志
relay_log=mall-mysql-relay-bin
## log_slave_updates表示slave将复制事件写进自己的二进制日志
log_slave_updates=1
## slave设置为只读（具有super权限的用户除外）
read_only=1

        3.重启容器

        4.在主数据库中查看主从同步

        5、在从数据库配置主从复制

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;

master_host：主数据库的IP地址；

master_port：主数据库的运行端口；

master_user：在主数据库创建的用于同步数据的用户账号；

master_password：在主数据库创建的用于同步数据的用户密码；

master_log_file：指定从数据库要复制数据的日志文件，通过查看主数据的状态，获取File参数；

master_log_pos：指定从数据库从哪个位置开始复制数据，通过查看主数据的状态，获取Position参数；

master_connect_retry：连接失败重试的时间间隔，单位为秒。

        6.在从数据库查看主从状态

show slave status \G;

        7.在从数据库中开启主从同步

start slave;

安装Redis集群

        面试题~ 1~2亿条数据缓存，设计缓存策略

        使用分布式存储，业界有三种解决方法

                                                                                                                                1.哈希取余分区

2亿条记录就是2亿个k,v，我们单机不行必须要分布式多机，假设有3台机器构成一个集群，用户每次读写操作都是根据公式： hash(key) % N个机器台数，计算出哈希值，用来决定数据映射到哪一个节点上。

优点：   简单粗暴，直接有效，只需要预估好数据规划好节点，例如3台、8台、10台，就能保证一段时间的数据支撑。使用Hash算法让固定的一部分请求落到同一台服务器上，这样每台服务器固定处理一部分请求（并维护这些请求的信息），起到负载均衡+分而治之的作用。

缺点：    原来规划好的节点，进行扩容或者缩容就比较麻烦了额，不管扩缩，每次数据变动导致节点有变动，映射关系需要重新进行计算，在服务器个数固定不变时没有问题，如果需要弹性扩容或故障停机的情况下，原来的取模公式就会发生变化：Hash(key)/3会变成Hash(key) /?。此时地址经过取余运算的结果将发生很大变化，根据公式获取的服务器也会变得不可控。 某个redis机器宕机了，由于台数数量变化，会导致hash取余全部数据重新洗牌。

        2.一致性哈希算法分区 

                一致性哈希算法解决分布式缓存数据变动和映射问题，目的是为了当服务器发生变动时，尽量减少客户端到服务器的映射关系

                优点：容错性和扩展性；        缺点：数据倾斜

为了在节点数目发生改变时尽可能少的迁移数据

将所有的存储节点排列在收尾相接的Hash环上，每个key在计算Hash后会顺时针找到临近的存储节点存放。

而当有节点加入或退出时仅影响该节点在Hash环上顺时针相邻的后续节点。  

优点

加入和删除节点只影响哈希环中顺时针方向的相邻的节点，对其他节点无影响。

缺点 

数据的分布和节点的位置有关，因为这些节点不是均匀的分布在哈希环上的，所以数据在进行存储时达不到均匀分布的效果。

        3.哈希槽分区

       解决数据倾斜问题

3主3从集群配置（哈希槽分区）

        1.新建6台redis容器

docker run -d --name redis-node-1 --net host --privileged=true -v /data/redis/share/redis-node-1:/data redis --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 --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 --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 --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 --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 --cluster-enabled yes --appendonly yes --port 6386

        2.进入1号容器配置主从关系

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

#--cluster-replicas 1 表示为每个master创建一个slave节点 两两配对

 

        3.查看集群状态

cluster info
cluster nodes

         主从容错切换迁移

        数据读写存储（写数据，自动跳转符合哈希槽的端口）

防止路由失败加入参数-c，优化路由
如：redis-cli -p 6381 -c    #以集群方式连接
redis-cli --cluster check 192.168.8.100:6381    #查看集群信息

         容错切换迁移（宕机补位）

        自带哨兵模式（主机死，从机变主机；前主机活，变为从）

        主从扩容

        需求：数据高峰，增加6387、6388 redis 进入集群完成四主四从 ,怎么分配哈希槽

        1.新建6387、6388两个容器

docker run -d --name redis-node-7 --net host --privileged=true -v /data/redis/share/redis-node-7:/data redis --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 --cluster-enabled yes --appendonly yes --port 6388

        2.将6387 作为master节点先加入集群

先进入6387容器内

将新增的6387作为master节点加入集群

redis-cli --cluster add-node 自己实际IP地址:6387 自己实际IP地址:6381

6387 就是将要作为master新增节点

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

        3.检查集群状况（第一次）

redis-cli --cluster check 真实ip地址:6381

        已经加入集群成功，但是没有分配哈希槽 

 

         4.从新分配槽号

 重新分派槽号

命令:redis-cli --cluster reshard IP地址:端口号

redis-cli --cluster reshard 192.168.8.100:6381

为什么6387是3个新的区间，以前的还是连续？ 重新分配成本太高，所以前3家各自匀出来一部分，从6381/6382/6383三个旧节点分别匀出1364个坑位给新节点6387

        5.第二次检查集群状态

redis-cli --cluster check 192.168.100:6381

为什么6387是3个新的区间，以前的还是连续？ 重新分配成本太高，所以前3家各自匀出来一部分，从6381/6382/6383三个旧节点分别匀出1364个坑位给新节点6387

        6.为主节点6387添加slave节点6388

命令：redis-cli --cluster add-node ip:新slave端口 ip:新master端口 --cluster-slave --cluster-master-id 新master主机节点ID redis-cli --cluster add-node 192.168.8.100:6388 192.168.8.100:6387 --cluster-slave --cluster-master-id 3e78e4444d1dd534f0c94482d07d59dd54154416-------这个是6387的编号，按照自己实际情况

         7.第三次检查集群状态

         四主四从完成

        集群缩容

        需求：数据高峰过去，删除6387、6388，回到三主三从模式

        1.先删从机再删主机

命令：redis-cli --cluster del-node ip:从机端口 从机6388节点ID
 
redis-cli --cluster del-node 192.168.8.100:6388 7f6c07b832b7eda329cafe04be9dbccb1eb6cca4
#删除6388从节点

         2.检查集群状态 （只有三台从机）

         3.重新分配槽号

redis-cli --cluster reshard 192.168.8.100:6381

         4.删除6387主节点

命令：redis-cli --cluster del-node ip:端口 6387节点ID
 
redis-cli --cluster del-node 192.168.8.100:6387 3e78e4444d1dd534f0c94482d07d59dd54154416

二、DockerFile解析

        是什么

        Dockerfile是用来构建Docker镜像的文本文件，是由一条条构建镜像所需的指令和参数构成的脚本。

        DockerFile构建

 Dockerfile面向开发，Docker镜像成为交付标准，Docker容器则涉及部署与运维，三者缺一不可，合力充当Docker体系的基石。

 

        编写自定义镜像步骤 

        虚悬镜像

 

docker image prune
删除虚悬镜像

         编写Dockerfile文件(运用Dockerfile常用保留字)

        将jdk8的压缩包放在和Dockerfile文件一起

FROM centos
MAINTAINER zzyy<zzyybs@126.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 glibc.i686
RUN mkdir /usr/local/java
#ADD 是相对路径jar,把jdk-8u171-linux-x64.tar.gz添加到容器中,安装包必须要和Dockerfile文件在同一位置
ADD jdk-8u171-linux-x64.tar.gz /usr/local/java/
#配置java环境变量
ENV JAVA_HOME /usr/local/java/jdk1.8.0_171
ENV JRE_HOME $JAVA_HOME/jre
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib:$CLASSPATH
ENV PATH $JAVA_HOME/bin:$PATH
 
EXPOSE 80
 
CMD echo $MYPATH
CMD echo "success--------------ok"
CMD /bin/bash

        构建

docker build -t 新镜像名:TAG .
如：docker build -t centosjava8:1.5 .
#Tag后面有点.

三、Docker微服务实战

        将打包好的Java工程jar包放在和Dockerfile文件一起

        编写Dockerfile文件

# 基础镜像使用java
FROM java:8
# 作者
MAINTAINER zzyy
# VOLUME 指定临时文件目录为/tmp，在主机/var/lib/docker目录下创建了一个临时文件并链接到容器的/tmp
VOLUME /tmp
# 将jar包添加到容器中并更名为zzyy_docker.jar
ADD docker_boot-0.0.1-SNAPSHOT.jar zzyy_docker.jar
# 运行jar包
RUN bash -c 'touch /zzyy_docker.jar'

ENTRYPOINT ["java","-jar","/zzyy_docker.jar"]

#暴露6001端口作为微服务

EXPOSE 6001

        在Dockerfile文件目录构建

docker build -t 新镜像名:TAG .

        运行容器

docker run -d -p 6001:6001 镜像名:TAG bash

四、Dcoker网络

        bridge

Docker 服务默认会创建一个 docker0 网桥（其上有一个 docker0 内部接口），该桥接网络的名称为docker0，它在内核层连通了其他的物理或虚拟网卡，这就将所有容器和本地主机都放到同一个物理网络。Docker 默认指定了 docker0 接口 的 IP 地址和子网掩码，让主机和容器之间可以通过网桥相互通信。

         Host（在配3主3从使用的就是Host）

        直接使用宿主机的 IP 地址与外界进行通信，不再需要额外进行NAT 转换。

docker run -d -p 8083:8080 --network host --name tomcat83 billygoo/tomcat8-jdk8    #有警告
docker run -d              --network host --name tomcat83 billygoo/tomcat8-jdk8    #正确

 

        none

        是什么

在none模式下，并不为Docker容器进行任何网络配置。 

也就是说，这个Docker容器没有网卡、IP、路由等信息，只有一个lo

需要我们自己为Docker容器添加网卡、配置IP等。

        案例

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

 container

        container⽹络模式 

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

        自定义网络 

1.自定义桥接网络,自定义网络默认使用的是桥接网络bridge

        2、新建容器加入上一步新建的自定义网络
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
        3.互ping测试

五、 Docker-compose容器编排

        是什么

Docker-Compose是Docker'官方的开源项目，
负责实现对Docker容器集群的快速编排。

        下载

Releases · docker/compose · GitHub

cd /usr/local/bin
mv docker-compose-Linux-x86_64 docker-compose
chmod 755 docker-compose
docker-compose -version

        卸载

        docker-compose常用命令

Compose常用命令

docker-compose -h                           # 查看帮助

docker-compose up                           # 启动所有docker-compose服务

docker-compose up -d                        # 启动所有docker-compose服务并后台运行

docker-compose down                         # 停止并删除容器、网络、卷、镜像。

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

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

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

 

docker-compose logs  yml里面的服务id     # 查看容器输出日志

docker-compose config     # 检查配置

docker-compose config -q  # 检查配置，有问题才有输出

docker-compose restart   # 重启服务

docker-compose start     # 启动服务

docker-compose stop      # 停止服务

 

         docker-compose编写微服务

        1.将Java工程打包成jar包上传到服务器

        2.使用Dockerfile将微服务打包成镜像文件

        3.使用docker-compose.yml 定义完整业务单元

        4.使用docker-compose up -d 一键部署

        docker-compose.yml文件

version: "3"

services:
  microService:
    image: zzbb_docker:1.1
    container_name: server
    ports:
      - "6001:6001"
    volumes:
      - /app/microService:/data
    networks: 
      - my_network 
    depends_on: 
      - redis626
      - mysql57

  redis:
    image: redis:latest
    container_name: redis626
    ports:
      - "6379:6379"
    volumes:
      - /app/redis/redis.conf:/etc/redis/redis.conf
      - /app/redis/data:/data
    networks: 
      - my_network
    command: redis-server /etc/redis/redis.conf

  mysql:
    image: mysql:5.7
    container_name: mysql57
    environment:
      MYSQL_ROOT_PASSWORD: '123456'
      MYSQL_ALLOW_EMPTY_PASSWORD: 'no'
      MYSQL_DATABASE: 'db2021'
      MYSQL_USER: 'zzbb'
      MYSQL_PASSWORD: 'zzbb123'
    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:
      - my_network
    command: --default-authentication-plugin=mysql_native_password #解决外部无法访问

networks: 
   my_network: 

六、Docker轻量级可视化工具Portainer 

        官网 

 

安装

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

网址：IP:9000