docker高级篇-初入分布式云原生-运维开发工程师

---

前言

文中部分资料来自于尚硅谷-周阳老师的课程

一.容器数据卷

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

docker run -d -p 5000:5000 [-v 宿主机的路径:容器内的路径 --privileged=true] registry # 生成registry镜像的容器
# -d 后台守护运行
# -p 指定暴露宿主机端口和映射端口
# -v 添加自定义容器卷

# 运行一个带有容器卷存储功能的容器实例
docker run -it --privileged=true -v /宿主机绝对路径目录:/容器内目录  --name=自定义容器名称 镜像名
docker run -it --privileged=true -v /宿主机绝对路径目录:/容器内目录:ro  --name=自定义容器名称 镜像名# 容器内只读
docker cp 容器id:容器内文件路径 目的主机路径 # 将容器内文件复制到主机上
docker export 容器id>文件名.tar # 导出容器的内容留作为一个tar归档文件
cat 文件名.tar | docker import - 镜像用户/镜像名:镜像版本号 
docker inspect 容器id # 
docker run -it --privileged=true --volumes-from 父类--name 自定义容器名称 镜像名 # 容器1继承容器2卷规则

容器和宿主机之间数据共享
1 docker修改，主机同步获得
2 主机修改，docker同步获得
3 docker容器stop，主机修改，docker容器重启看数据是否同步。

二.docker安装常用软件

docker search 软件名
docker pull 软件名
docker run 软件名

2.1 tomcat安装

docer search tomcat #
docker pull tomcat[:版本号] # 拉取tomcat
docker images tomcat # 查看镜像是否拉取成功
docker run -d -p 8080:8080 --name t1 tomcat # 指定端口运行
docker ps # 查看是否启动成功
# 注意防火墙放行
docker exec -it tomcat容器id /bin/bash # 进入tomcat实例容器,将webapps.dist修改为webapps

2.2 mysql安装

注意中文乱码和数据备份,降低坐牢风险

docker search mysql
docker pull mysql[:版本号] # 拉取mysql
docker images mysql
ps -ef | grep mysql # 注意docker mysql端口和宿主机端口冲突

# -----------------数据备份-----------------
docker run -d -p 3306:3306 --privileged=true \
-v /mysql/log:/var/log/mysql \
-v /mysql/data:/var/lib/mysql \
-v /mysql/conf:/etc/mysql \
-v /mysql/mysql-files:/var/lib/mysql-files/ \
-e TZ=Asia/Shanghai \
--restart=always \
-e MYSQL_ROOT_PASSWORD=123456 --name mysql mysql:8.0.26 \
--character-set-server=utf8mb4 \
--collation-server=utf8mb4_unicode_ci \
--default-authentication-plugin=mysql_native_password

# -----------------------------------------

docker ps # 查看容器是否正常运行
vi /mysql/conf/my.cnf
=====配置内容=====
[client]
default-character-set=utf8mb4

[mysql]
default-character-set=utf8mb4

[mysqld]
init_connect='SET collation_connection = utf8mb4_unicode_ci'
init_connect='SET NAMES utf8mb4'
character-set-server=utf8mb4
collation-server=utf8mb4_unicode_ci
skip-character-set-client-handshake

docker exec -it mysql bash
mysql -uroot -p 第一次登陆无密码

开启mysql远程登陆

use mysql;
update user set host='%' where user='root';
Grant all privileges on root.* to 'root'@'%';  #执行两次
alter user root identified with mysql_native_password by '123456';
FLUSH PRIVILEGES;
show variables like 'character%'; # 查看字符编码

docker安装完MySQL并run出容器后，建议请先修改完字符集编码后再新建mysql库-表-插数据

2.2.2 mysql主从复制

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[:版本号]
# -------------------------------------------
docker ps
cd /mydata/mysql-master/conf
vi my.cnf
# -----------vi 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
# --------------------------------
docker restart mysql-master
docker exec -it mysql-master /bin/bash

数据库授权同步数据用户 ☯☯☯☯☯☯☯☯☯

CREATE USER 'slave'@'%'IDENTIFIED BY '123456';
GRANT REPLICATION SLAVE,REPLICATION CLIENT ON *.* TO 'slave'@ '%';

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[:版本号]
# -------------------------------------------

docker ps
cd /mydata/mysql-slave/conf
vi my.cnf
# -----------vi 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=mali- mysql- relay- bin
## log_slave_updates表示slave将复制事件写进自己的二进制日志
log_slave_updates=1
##slave设置为只读(具有super权限的用户除外)
read_only=1
# --------------------------------
docker restart mysql-slave
docker exec -it mysql- slave /bin/bash

在从机mysql中
master_user请看上方相同标志 ☯☯☯☯☯☯☯☯

# 主从复制命令参数说明
# master_host:主数据库的IP地址;
# master_port:主数据库的运行端口;
# master_user:在主数据库创建的用于同步数据的用户账号;
# master_password:在主数据库创建的用于同步数据的用户密码;
# master_log_file:指定从数据库要复制数据的日志文件|I通过查看主数据的状态，获取File参数;
# master_log_pos:指定从数据库从哪个位置开始复制数据，通过查看主数据的状态，获取Position参数;
# master_connect_retry:连接失败重试的时间间隔，单位为秒。

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;
start slave;
show slave status;

主从测试

2.3 redis安装

注意中文乱码和数据备份,降低坐牢风险

docker search redis
docker pull redis:6.0 # 拉取redis
mkdir -p /mydata/redis/conf
touch /mydata/redis/conf/redis.conf

# 拷贝官方redis.conf文件 到/mydata/redis/conf/redis.conf (注意切勿创建成redis.conf目录)

# ---------vi redis.conf --------------
# 修改如下内容
requirepass 密码
masterauth 密码
# bind 127.0.0.1
protected-mode no
daemonize no #docker -d 具有守护线程功能,防止docker冲突
# -------------------------------------
docker run -p 6379:6379 --name redis --privileged=true \
-v /mydata/redis/conf/redis.conf:/etc/redis/redis.conf \
-v /mydata/redis/data:/data \
--restart=always \
-d redis:6.0 redis-server /etc/redis/redis.conf

docker ps # 查看是否启动容器成功
dcoker exec -it redis容器id /bin/bash

三.分布式哈希算法

1~2亿条数据需要缓存,请问如何设计这个存储案例

3.1 分布式存储之哈希取余算法

分布式存储之哈希取余算法
2亿条记录就是2亿个k-v，必须要分布式多机，假设有N台机器构成一个集群，用户每次读写操作都是根据公式:hash(key)%N个机器台数，计算出哈希值，用来决定数据映射到哪一个节点上。
优点: 简单粗暴，直接有效，只需要预估好数据规划好节点，就能保证一段时间的数据支撑。使用Hash算法让固定的一部分请求落到同一台服务器上。这样每台服务器固定处理一部分请求（并维护这些请求的信息），起到负载均衡+分而治之的作用。
缺点: 在服务器个数固定不变时没有问题，如果需要弹性扩容或故障停机的情况下，每次数据变动导致节点有变动，映射关系需要重新进行计算.原来的取模公式就会发生变化:Hash(key)/N会变成Hash(key)/? 。此时地址经过取余运算的结果将发生很大变化，根据公式获取的服务器也会变得不可控.

3.2 一致性哈希算法

步骤:
算法构建一致性哈希环;
服务器IP节点映射;
key落到服务器的落键规则Z

算法构建一致性哈希环

服务器IP节点映射
将集群中各个IP节点映射到环上的某一个位置。将各个服务器使用Hash进行一个哈希，具体可以选择服务器的IP或主机名作为关键字进行哈希，这样每台机器就能确定其在哈希环上的位置。假如4个节点NodeA、B、C、D，经过IP地址的哈希函数计算(hash(ip)).

key落到服务器的落键规则

一致性哈希算法
容错性: 顺时针沿环行走,第一台遇到的服务器就是其应该定位到的服务器,并将该键值对存储在该节点上.当遇到的服务器出现问题时,跳过继续顺时针沿环向前行走.
扩展性: 在环中添加一个站点,不会影响一致性hash取余算法.
缺点: 数据倾斜问题.当服务器节点过少,容易因为节点分布不均匀而造成数据倾斜

3.3 哈希槽分区

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

redis默认槽;一个集群只能有16384个槽，编号0-16383(0-2M14-1)。这些槽会分配给集群中的所有主节点，分配策略没有要求。可以指定哪些编号的槽分配给哪个主节点。集群会记录节点和槽的对应关系。解决了节点和槽的关系后，接下来就需要对key求哈希值，然后对16384取余，余数是几key就落入对应的槽里。slot =CRC16(key) % 16384。以槽为单位移动数据，因为槽的数目是固定的，处理起来比较容易，这样数据移动问题就解决了。

CRC16算法产生的hash值有16bit，该算法可以产生2^16=65536个值。换句话说值是分布在0~65535之间。那作者在做mod运算的时候，为什么不mod65536，而选择mod16384?

四.redis集群配置

4.1 三主三从

关闭防火墙+启动docker服务

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

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
# =========================

#==========进入一台redis容器=========
docker exec -it redis-node-1 /bin/bash
# 集群合体
redis-cli --cluster create ip:port ip:port ip:port ip:port ip:port ip:port --cluster-replicas 1
# **********进入redis***********
redis-cli -p port
cluster info # 查看集群状态
cluster nodes # 查看集群主从详细情况
# **********进入redis***********
#==========进入一台redis=========

集群模式启动redis方式 redis-cli -p port -c

redis-cli --cluster check ip:port # 集群检查

4.2 主从容错切换

当某一主机挂掉,对应从机自动升格为大哥(主机)(有一定延迟);当挂掉的主机重连变为小弟(从机)
当某一个主从都挂了: 在redis.conf中若 cluster-require-full-coverage yes则整个集群挂掉
若 cluster-require-full-coverage no则其他集群不受影响.

4.3 主从扩缩容-弹性云

槽位变化,新机的加盟

4.3.1 扩容

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

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

#====进入6387 master容器内部====
docker exec -it redis-node-7 /bin/bash
cluster check ip:port # 查看集群主从详细情况
redis-cli --cluster add-node ip:6387 ip:6381 # 将ip:6387主机加入ip:6381所属的集群中
redis-cli --cluster reshard ip:port # 重新分配槽号(16384/n) 节点编号 all 全部分配 yes
cluster check ip:port # 查看集群主从详细情况
#====进入6387容器内部====

不全盘打乱重新编号,而是将多余的分给新来的凑够16384/n个槽位

挂载从机

#====进入6388 slave容器内部====
docker exec -it redis-node-7 /bin/bash
cluster check ip:port # 查看集群主从详细情况

# 将ip:6388作为ip:6387的从机
redis-cli --cluster add-node ip:6388 ip:6387 --cluster-slave --cluster-master-id 主机编号
cluster check ip:port # 查看集群主从详细情况
#====进入6388 slave容器内部====

4.3.2 缩容

redis-cli --cluster del-node ip:从机端口 从机节点编号id # 移除从机
redis-cli --cluster reshard ip:port # 重新分配槽号(16384/n) 节点编号 all 全部分配 yes

4096个槽位都指给6381，它变成了8192个槽位，相当于全部都给6381了，不然要输入3次.

cluster check ip:port # 查看集群主从详细情况
redis-cli --cluster del-node ip:主机端口 主机节点编号id # 移除主机
cluster check ip:port # 查看集群主从详细情况

五.Dockerfile

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

1.编写dockerFile 文件
2.docker build 构建镜像
3.docker run 运行容器实例

5.1 dockerfile基础

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

dockerFile保留字

5.2 Dockerfile编写

FROM centos:7
MAINTAINER yuanjie<782353676@qq.com>
ENV MYPATH /usr/local
WORKDIR $MYPATH

#安装vim编辑器
RUN yum -y install vim

#安装ifconfig命令查看网络IP
RUN yum -y install net-tools

#安装java11及lib库
RUN yum -y install glibc.i686
RUN mkdir /usr/local/java

#ADD 是相对路径jar,把jdk-11.0.12_linux-x64_bin.tar.gz添加到容器中,安装包必须要和Dockerfile文件在同一位置
ADD jdk-11.0.12_linux-x64_bin.tar.gz /usr/local/java/
#配置java11环境变量
ENV JAVA_HOME /usr/local/java/jdk-11.0.12
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 run -it 新镜像名:TAG

5.3 虚悬镜像

Dockerfile构建或删除时出现一些错误,导致仓库或tag都是none.查出直接删除
docker image ls -f dangling=true

docker image prune

六.docker-network

6.1 简介

在CentOS7的安装过程中如果有选择相关虚拟化的的服务安装系统后，启动网卡时会发现有一个以网桥连接的私网地址的virbr0)网卡(virbr0网卡:它还有一个固定的默认IP地址192.168.122.1)，是做虚拟机网桥的使用的，其作用是为连接其上的虚机网卡提供NAT访问外网的功能。

docker启动后,会产生一个docker0的虚拟网桥.

docker network的网络模式命令

网络模式	简介
bridge	为每个容器分配,设置ip等,并将容器连接到一个docker0,虚拟网桥,默认为该模式 使用–network bridge指定
host	容器将不会虚拟出自己的网卡,培植自己的ip等,而是使用宿主机的ip和端口 使用–network host指定
none	容器有独立的Network namespace,但并没有对其进行任何网络设置 使用–network none指定
container	新创建的容器不会创建自己的网卡和配置自己的ip.而是和一个指定的容器共享ip.端口范围. 使用–network container:容器名/容器id指定

6.2 network的作用

同一网段，docker不明显
docker网路管理和容器调用之间的规划
容器lP变动时候可以通过服务名直接网络通信而不受到影响

6.2.1 bridge

每创建一个容器实例其内部都会存在 独立的eth0网卡.它们都需要通过虚拟出的docker0网桥进行容器与容器,容器与宿主机的信息交换
两个容器在同一个网络下,会从这个网关下各自拿到分配的ip，此时两个容器的网络是互通的

6.2.2 host

容器将不会获得一个独立的Network Namespace，而是和宿主机共用一个Network Namespace。容器将不会虚拟出自己的网卡而是使用宿主机的IP和端口。|

6.2.3 none

禁用网络功能，只有lo标识(就是127.0.0.1表示本地回环)

6.2.4 container

新创建的容器不会创建自己的网卡和配置自己的ip.而是和一个指定的容器共享ip.端口范围. 使用–network container:容器名/容器id指定
注意端口冲突!

6.2.5 自定义网络

为避免容器重启造成的ip变化,我们不应当直接连接ip,而是通过容器名映射到对应的ip.而这正需要自定义网络来做

# 新建自定义网络,未指明何种模式.默认bridge
docker network create yuanjie_network
# 将新建容器加入上一步新建的自定义网络
docker run -d -p 8081:8080 --network yuanjie_network --name=tomcat81 billygoo/tomcat8-jdk8 # 服务名tomcat81
docker run -d -p 8082:8080 --network yuanjie_network --name=tomcat82 billygoo/tomcat8-jdk8 # 服务名tomcat82

测试

ping tomcat81
ping tomcat82

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

七.Docker-compose容器编排

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

Compose是Docker公司推出的一个工具软件，可以管理多个Docker容器组成一个应用。你需要定义一个YAML格式的配置文件docker-compose.yml，写好多个容器之间的调用关系,同时避免容器重启,ip对应关系出错。然后只要一个命令，就能同时启动/关闭这些容器.

8.1 docker-compose工具下载

官方参考手册
官方安装参考地址

7.2 docker-compose的核心理念

一个文件: docker-compose.yaml
两个要素:
服务: 一个个应用容器实例
工程: 一组关联的容器组成完整的业务单元

7.3 微服务工程上传docker

将idea打包好的jar包,上传至linux宿主机,在同路径下编写vi Dockerfile

vi Dockerfile

# 基础镜像使用java
FROM java:11

# 作者
MAINTAINER yuanjie

# VOLUME 指定临时文件目录为/tmp，在主机/var/lib/docker目录下创建了一个临时文件并链接到容器的/tmp
VOLUME /tmp

# 将jar包添加到容器中并更名为yuanjie_docker.jar
ADD docker_boot-0.0.1-SNAPSHOT.jar yuanjie_docker.jar

# 运行jar包
RUN bash -c 'touch /yuanjie_docker.jar'
ENTRYPOINT ["java","-jar","/yuanjie_docker.jar"," >data.log 2"]

#暴露8080端口作为微服务
EXPOSE 8080

构建镜像

docker build -t yuanjie_docker:TAG

创建实例容器
注意变更宿主机防火墙需要重启docker

docker run -d -p 8080:8080 镜像id

编写docker-compose.yml 文件

# compose是3.x版本
version: "3"
# 填写服务容器实例
services:
  # 定义微服务项目
  microService:
    image: yuanjie_docker:TAG
    container_name: 容器名
    ports:
      - "6001:6001"
    # 容器数据卷,做好备份
    volumes:
      - /app/microService:/data
    # 统一网络配置 
    networks: 
      - project01_net
    # 微服务依赖的其他容器
    depends_on: 
      - redis
      - mysql
  # 对外暴露服务名redis,注意jar包中spring.redis.host=redis
  redis:
    image: redis:6.0.8
    ports:
      - "6379:6379"
    volumes:
      - /app/redis/redis.conf:/etc/redis/redis.conf
      - /app/redis/data:/data
    networks: 
      - project01_net
    # 启动redis命令
    command: redis-server /etc/redis/redis.conf
  # 对外暴露服务名mysql,注意jar包中spring.mysql.host=mysql
  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: '123456'
      MYSQL_ALLOW_EMPTY_PASSWORD: 'no'
      MYSQL_DATABASE: 'music'
      MYSQL_USER: 'user'
      MYSQL_PASSWORD: '123456'
    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:
      - project01_net
    command: --default-authentication-plugin=mysql_native_password #解决外部无法访问

networks: 
   project01_net: # 什么也不写,默认bridge模式

构建镜像

docker build -t yuanjie_docker:TAG

运行compose

docker-compose up -d 

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      # 停止服务

八. Portainer轻量级可视化管理docker工具 (运维系)

集群环境建议直接上k8s
目的:监控和统计,它提供了图形化界面,傻瓜式一键操作,用于方便地管理Docker环境,包括单机环境和集群环境

下载地址

#####start#####
# 多端口映射  --restart=always保证和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
#####end#####

访问地址 ip:端口号

剩余一键傻瓜式操作

九. CAdvisor+InfluxDB+Granfana重量级监控 (运维系)

不使用重量级监控存在的问题: docker stats 只能统计当前宿主机的全部容器,数据资料实时无法存储,也无法预警

CAdvisor(监控收集): 容器资源监控工具,具备可视化实时监控容器运行状态.默认本机保存最近2min的数据 主要用于展示主机和容器的数据历史变化数据.

InfluxDB(存储数据): 开源分布式时序,事件和指标数据库,无需外部依赖.主要用于持久化存储CAdvisor,基于时间序列,可度量性,基于事件支持任意数据类型

Granfana: 开源的数据监控分析可视化平台,支持多种数据源配置,支持图表权限控制和报警.

9.1 compose容器编排重量级监控

# 新建目录
mkdir cig
cd cig
vi docker-compose.yml
##### vi docker-compose.yml ##### 
version: '3.1'
# 挂载grafana_data数据卷
volumes:
  grafana_data: {}

services:
# 创建数据库cadvisor
 influxdb:
  image: tutum/influxdb:0.9
  restart: always
  environment:
    - PRE_CREATE_DB=cadvisor
  # 对外暴露的端口
  ports:
    - "8083:8083"
    - "8086:8086"
  # influxdb数据卷挂载
  volumes:
    - ./data/influxdb:/data
   
 cadvisor:
  image: google/cadvisor
  # cadvisor数据库连接容器influxsrv
  links:
    - influxdb:influxsrv
  command: -storage_driver=influxdb -storage_driver_db=cadvisor -storage_driver_host=influxsrv:8086
  restart: always
  ports:
    - "8080:8080"
  volumes:
    - /:/rootfs:ro
    - /var/run:/var/run:rw
    - /sys:/sys:ro
    - /var/lib/docker/:/var/lib/docker:ro

 grafana:
  user: "104"
  image: grafana/grafana
  user: "104"
  restart: always
  links:
    - influxdb:influxsrv
  ports:
    - "3000:3000"
  volumes:
    - grafana_data:/var/lib/grafana
  environment:
    - HTTP_USER=admin
    - HTTP_PASS=admin
    - INFLUXDB_HOST=influxsrv
    - INFLUXDB_PORT=8086
    - INFLUXDB_NAME=cadvisor
    - INFLUXDB_USER=root
    - INFLUXDB_PASS=root
##### vi docker-compose.yml ##### 

docker-compose up

详细配置请看这位大佬的文章

十.终章

传送门