Docker尚硅谷_高级篇

高级篇

一、Dockerfile

1.1 Dockerfile

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

构架步骤

编写Dockerfile文件
docker build 命令构建镜像
docker run 依据镜像运行容器实例

1.2 构建过程

Dockerfile编写

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

Docker引擎执行Docker的大致流程

Docker从基础镜像运行一个容器
执行一条指令并对容器做出修改
执行类似docker commit的操作提交一个新的镜像层
docker再基于刚提交的镜像运行一个新容器
执行Dockerfile中的下一条指令，直到所有指令都执行完成

1.3 Dockerfile保留字

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

# FROM 镜像名
FROM hub.c.163.com/library/tomcat

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

# 非必须
MAINTAINER ZhangSan zs@163.com

RUN
容器构建时需要运行的命令。

有两种格式：

shell格式

# 等同于在终端操作的shell命令
# 格式：RUN <命令行命令>
RUN yum -y install vim

exec格式

# 格式：RUN ["可执行文件" , "参数1", "参数2"]
RUN ["./test.php", "dev", "offline"]  # 等价于 RUN ./test.php dev offline

RUN是在docker build时运行

EXPOSE
当前容器对外暴露出的端口。

# EXPOSE 要暴露的端口
# EXPOSE <port>[/<protocol] ....
EXPOSE 3306 33060

WORKDIR
指定在创建容器后，终端默认登录进来的工作目录。

ENV CATALINA_HOME /usr/local/tomcat
WORKDIR $CATALINA_HOME

USER
指定该镜像以什么样的用户去执行，如果不指定，默认是root。（一般不修改该配置）

# USER <user>[:<group>]
USER patrick

ENV
用来在构建镜像过程中设置环境变量。

这个环境变量可以在后续的任何RUN指令或其他指令中使用

# 格式 ENV 环境变量名 环境变量值
# 或者 ENV 环境变量名=值
ENV MY_PATH /usr/mytest

# 使用环境变量
WORKDIR $MY_PATH

VOLUME
容器数据卷，用于数据保存和持久化工作。类似于 docker run 的-v参数。

# VOLUME 挂载点
# 挂载点可以是一个路径，也可以是数组（数组中的每一项必须用双引号）
VOLUME /var/lib/mysql

ADD
将宿主机目录下（或远程文件）的文件拷贝进镜像，且会自动处理URL和解压tar压缩包。
COPY
类似ADD，拷贝文件和目录到镜像中。
将从构建上下文目录中<源路径>的文件目录复制到新的一层镜像内的<目标路径>位置。

COPY src dest
COPY ["src", "dest"]
# <src源路径>：源文件或者源目录
# <dest目标路径>：容器内的指定路径，该路径不用事先建好。如果不存在会自动创建

CMD
指定容器启动后要干的事情。
有两种格式：

shell格式

# CMD <命令>
CMD echo "hello world"

exec格式

# CMD ["可执行文件", "参数1", "参数2" ...]
CMD ["catalina.sh", "run"]

参数列表格式

# CMD ["参数1", "参数2" ....]，与ENTRYPOINT指令配合使用

Dockerfile中如果出现多个CMD指令，只有最后一个生效。CMD会被docker run之后的参数替换。
例如，对于tomcat镜像，执行以下命令会有不同的效果：

# 因为tomcat的Dockerfile中指定了 CMD ["catalina.sh", "run"]
# 所以直接docker run 时，容器启动后会自动执行 catalina.sh run
docker run -it -p 8080:8080 tomcat

# 指定容器启动后执行 /bin/bash
# 此时指定的/bin/bash会覆盖掉Dockerfile中指定的 CMD ["catalina.sh", "run"]
docker run -it -p 8080:8080 tomcat /bin/bash

CMD是在docker run时运行，而 RUN是在docker build时运行。

ENTRYPOINT
用来指定一个容器启动时要运行的命令。

类似于CMD命令，但是ENTRYPOINT不会被docker run后面的命令覆盖，这些命令参数会被当做参数送给ENTRYPOINT指令指定的程序。
ENTRYPOINT可以和CMD一起用，一般是可变参数才会使用CMD，这里的CMD等于是在给ENTRYPOINT传参。
当指定了ENTRYPOINT后，CMD的含义就发生了变化，不再是直接运行期命令，而是将CMD的内容作为参数传递给ENTRYPOINT指令，它们两个组合会变成 <ENTRYPOINT> “<CMD>”。
例如：

FROM nginx

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

对于此Dockerfile，构建成镜像 nginx:test后，如果执行；

docker run nginx test，则容器启动后，会执行 nginx -c /etc/nginx/nginx.conf
docker run nginx:test /app/nginx/new.conf，则容器启动后，会执行 nginx -c /app/nginx/new.conf

1.3 构建镜像

构建镜像
创建名称为Dockerfile的文件，示例：

FROM ubuntu
MAINTAINER lee<[email protected]>

ENV MYPATH /usr/local
WORKDIR $MYPATH

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

EXPOSE 80

CMD echo $MYPATH
CMD echo "install ifconfig cmd into ubuntu success ....."
CMD /bin/bash

编写完成之后，将其构建成docker镜像。
命令：

# 注意：定义的TAG后面有个空格，空格后面有个点
# docker build -t 新镜像名字:TAG .
docker build -t ubuntu:1.0.1 .

1.4 虚悬镜像

虚悬镜像：仓库名、标签名都是的镜像，称为 dangling images（虚悬镜像）。
在构建或者删除镜像时可能由于一些错误导致出现虚悬镜像。
例如：

# 构建时候没有镜像名、tag
docker build .

列出docker中的虚悬镜像：

docker image ls -f dangling=true

虚悬镜像一般是因为一些错误而出现的，没有存在价值，可以删除：

# 删除所有的虚悬镜像
docker image prune

二、Docker发布微服务

2.1 搭建SpringBoot项目

搭建一个简单的SpringBoot项目：

创建maven工程，pom为：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.6</version>
    </parent>

    <groupId>org.study</groupId>
    <artifactId>test-docker</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>docker_boot</module>
    </modules>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

</project>

新建Module，pom为：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>test-docker</artifactId>
        <groupId>org.study</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>docker_boot</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

编写一个配置文件

server:
  port: 6001

编写主启动类

package com.study;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @author tengyer 2022/05/06 16:34
 */
@SpringBootApplication
public class DockerBootApplication {
    public static void main(String[] args) {
        SpringApplication.run(DockerBootApplication.class, args);
    }
}

编写一个Controller

package com.study.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import java.util.UUID;

/**
 * @author tengyer 2022/05/06 16:35
 */
@RestController
public class OrderController {
    @Value("${server.port}")
    private String port;

    @RequestMapping("/order/docker")
    public String helloDocker() {
        return "hello world \t" + port + "\t" + UUID.randomUUID().toString();
    }

    @RequestMapping(value = "/order/index", method = RequestMethod.GET)
    public String index() {
        return "服务端口号：" + "\t" + port + "\t" + UUID.randomUUID().toString();
    }
}

在Idea中运行没有问题时，将其使用maven的package打成jar包。

2.2 发布微服务项目到Docker容器

将项目jar包上传到服务器
编写Dockerfile

FROM openjdk:8-oracle
MAINTAINER lee

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

# 将jar包添加到容器中，并命名为 springboot_docker.jar
ADD docker_boot-1.0-SNAPSHOT.jar /springboot_docker.jar
# 运行jar包
RUN bash -c 'touch /springboot_docker.jar'
ENTRYPOINT ["java", "-jar", "/springboot_docker.jar"]

# SpringBoot项目配置的端口号为6001，需要将6001暴露出去
EXPOSE 6001

构建镜像

docker build -t springboot_docker:1.0 .

启动容器：

docker run -d -p 6001:6001 --name springboot springboot_docker:1.0

三、Docker网络

3.1 Docker网络

docker安装并服务后，会在宿主机中添加一个虚拟网卡。
在Docker服务启动前，使用ifconfig或ip addr查看网卡信息：

ens33或eth0:本机网卡
lo:本机回环网络网卡
可能有virbro(Centos安装时如果选择的有相关虚拟化服务，就会多一个以网桥连接的私网地址的virbr0网卡，作用是为连接虚拟网卡提供NAT访问外网的功能。如果要移除该服务，可以使用 yum remove libvirt-libs.x86_64)

使用 systemctl start docker启动Docker服务后，会多出一个 docker0 网卡。
作用：

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

Docker容器的网络隔离，是通过Linux内核特性 namespace和cgroup实现的。

3.2 docker网络命令

查看docker网络模式

docker network ls

如果没有修改过docker network，则默认有3个网络模式：

bridge
host
none

添加Docker网络

docker network add xxx

删除Docker网络

docker network rm xxx

查看网络元数据

docker network inspect xxx

删除所有无效的网络

docker network prune

3.3 Docker网络模式

Docker的网络模式：

简介	使用方式
为每一个容器分配、设置IP等，并将容器连接到一个docker0虚拟网桥，默认为该模式	–network bridge
容器将不会虚拟出自己的网卡、配置自己的IP等，而是使用宿主机的IP和端口	–network host
容器有独立的 Network namespace，但并没有对齐进行任何网络设置，如分配 veth pari和网桥连接、IP等	–network none
新创建的容器不会创建自己的网卡和配置自己的IP，而是和一个指定的容器共享IP、端口范围等	–network container:NAME或者容器ID

查看某个容器的网络模式：

# 通过inspect获取容器信息，最后20行即为容器的网络模式信息
docker inspect 容器ID | tail -n 20

3.4 docker0

Docker 服务默认会创建一个docker0网桥（其上有一个docker0内部接口），该桥接网络的名称为 docker0，它在内核层连通了其他的物理或虚拟网卡，这就将所有容器和本地主机都放到同一个物理网络。

Docker默认指定了docker0接口的IP地址和子网掩码，让主机和容器之间可以通过网桥互相通信。

查看bridge网络的详细信息，并通过grep获取名称:

docker network inspect bridge | grep name

可以看到其名称为docker0。

3.5 bridge模式

Docker使用Linux桥接，在宿主机虚拟一个Docker容器网桥（docker0），Docker启动一个容器时会根据Docker网桥的网段分配给容器一个IP地址，称为Container-IP，同时Docker网桥是每个容器的默认网关。因为在同一个宿主机内的容器接入同一个网桥，这样容器之间就能够通过容器的Container-IP直接通信。
docker run的时候，没有指定--network的话，默认使用的网桥模式就是bridge，使用的就是docker0。在宿主机ifconfig就可以看到docker0和自己create的network。
网桥docker0创建一对对等虚拟设备接口，一个叫veth，另一个叫eth0，成对匹配：
整个宿主机的网桥模式都是docker0，类似一个交换机有一堆接口，每个接口叫 veth，在本地主机和容器内分别创建一个虚拟接口，并让他们彼此联通（这样一对接口叫做 veth pair）。
每个容器实例内部也有一块网卡，容器内的网卡接口叫做eth0。
docker0上面的每个veth匹配某个容器实例内部的eth0，两两配对，一一匹配。

在这里插入图片描述
例如：

启动tomcat容器，进入tomcat容器后，执行 ip addr，可以看到其网卡信息：

1: lo ..................

容器内的网卡为 eth0
@符号后面就是宿主机上对应的veth网卡的编号28
27: eth0@if28 ...............................

在宿主机执行 ip addr 查看宿主机网卡信息：

每个veth都有个编号：vethXXXXXX
@符号后面对应就是容器内的eth0网卡编号27

28: vethXXXXXX@if27  ................

3.6 host模式

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

如果在 docker run 命令中同时使用了 --network host 和 -p端口映射，例如：

docker run -p 8082:8080 --network host tomcat

那么会出现一个警告：

WARNING: Published ports are discarded when using host network mode

因为此时已经使用了host模式，本身就是直接使用的宿主机的IP和端口，此时的-p端口映射就没有了意义，也不会生效，端口号还是会以主机端口号为主。

正确做法是：不再进行-p端口映射，或者改用bridge模式

3.7 none模式

禁用网络功能。
在none模式下，并不为docker容器进行任何网络配置。进入容器内，使用 ip addr查看网卡信息，只能看到 lo（本地回环网络127.0.0.1网卡）。

3.8 container模式

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

docker run -it --name alpine1 alpine /bin/sh

# 指定和 alpine1 容器共享网络
docker run -it --netrowk container:alpine1 --name alpine2 alpine /bin/sh

此时使用 ip addr查看两台容器的网络，会发现两台容器的eth0网卡内的IP等信息完全相同。
如果关掉了alpine1容器，因为alpine2的网络使用的alpine1共享网络，所以关掉alpin1后，alpine2的eth0网卡也随之消失了。

3.9 自定义网络

容器间的互联和通信以及端口映射。
容器 IP 变动时候可以通过服务名直接网络通信而不受影响。（类似Eureka，通过服务名直接互相通信，而不是写死IP地址）。

docker中还有一个 --link 进行容器网络互联，但是已经被标记为过时的，可能会在将来的版本中移除这个功能。推荐使用自定义网络替换link。

自定义桥接网络（自定义网络默认使用的是桥接网络 bridge）：

新建自定义网络

docker network create tomcat_network

查看网络列表

docker network ls

创建容器时，指定加入我们自定义的网络中

docker run -d -p 8081:8080 --network tomcat_network --name tomcat1 tomcat:8.5-jdk8-corretto

docker run -d -p 8082:8080 --network tomcat_network --name tomcat2 tomcat:8.5-jdk8-corretto

此时进入tomcat1中，使用ping命令测试连接tomcat2容器名，发现可以正常连通

# 安装ifconfig命令
yum install -y net-tools
# 安装ip addr命令
yum install -y iproute
# 安装ping命令
yum install -y iputils

# 直接ping容器名，不需要ping IP地址
ping tomcat2

3.10 link连接

示例：

# 启动一台mysql容器
# --name 为容器指定一个别名
docker run --name mysql-matomo -p 3308:3306 -e MYSQL_ROOT_PASSWORD=root -d mysql:8.0.28

# 启动另一个容器，通过--link连接到mysql容器
# --link 容器名称:本容器连接对方时的别名
docker run -d -p 8888:80 --link mysql-matomo:db --name matomo matomo:4.9.0

# 此时，在matomo容器中，便可以通过 db 这个hostname连接到mysql-matomo容器，而无须再通过ip
# 连接地址：db:3306

四、Docker-compose容器编排

4.1 Docker-compose

Docker-Compose 是 Docker 官方的开源项目，负责实现对Docker容器集群的快速编排。
Docker-Compose可以管理多个Docker容器组成一个应用。需要定义一个yaml格式的配置文件 docker-compose.yml，配置好多个容器之间的调用关系，然后只需要一个命令就能同时启动/关闭这些容器。
Docker建议我们每个容器中只运行一个服务，因为Docker容器本身占用资源极少，所以最好是将每个服务单独的分割开来。但是如果我们需要同时部署多个服务，每个服务单独构建镜像构建容器就会比较麻烦。所以 Docker 官方推出了 docker-compose 多服务部署的工具。
Compose允许用户通过一个单独的 docker-compose.yml 模板文件来定义一组相关联的应用容器为一个项目（project）。可以很容易的用一个配置文件定义一个多容器的应用，然后使用一条指令安装这个应用的所有依赖，完成构建。
核心概念：
- 服务（service）：一个个应用容器实例
- 工程（project）：由一组关联的应用容器组成的一个完整业务单元，在docker-compose.yml中定义
Compose使用的三个步骤：
- 编写 Dockerfile 定义各个应用容器，并构建出对应的镜像文件
- 编写 docker-compose.yml，定义一个完整的业务单元，安排好整体应用中的各个容器服务
- 执行docker-compose up命令，其创建并运行整个应用程序，完成一键部署上线

4.2 安装Docker-Compose

Docker-Compose的版本需要和Docker引擎版本对应，可以参照官网上的对应关系。
安装Compose：

# 例如从github下载 2.5.0版本的docker-compose
# 下载下来的文件放到 /usr/local/bin目录下，命名为 docker-compose
curl -L https://github.com/docker/compose/releases/download/v2.5.0/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose

# 添加权限
chmod +x /usr/local/bin/docker-compose

# 验证
docker-compose version

卸载Compose：直接删除 usr/local/bin/docker-compose文件即可

4.3 常用命令

执行命令时，需要在对应的docker-compose.yml文件所在目录下执行。
查看帮助：

docker-compose -h

创建并启动docker-compose服务：（类似 docker run）

docker-compose up

# 后台运行
docker-compose up -d

停止并删除容器、网络、卷、镜像：（类似 docker stop + docker rm）

docker-compose down

进入容器实例内部：

docker-compose exec <yml里面的服务id> /bin/bash

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

docker-compose ps

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

docker-compose top

查看容器输出日志：

docker-compose log <yml里面的服务id>

检查配置：

docker-compose config

# 有问题才输出
docker-compose config -q

重启服务：

docker-compose restart

启动服务：（类似 docker start）

docker-compose start

停止服务：

docker-compose stop

4.4 compose编排实例

示例：

# docker-compose文件版本号
version: "3"

# 配置各个容器服务
services:
  microService:
    image: springboot_docker:1.0
    container_name: ms01  # 容器名称，如果不指定，会生成一个服务名加上前缀的容器名
    ports:
      - "6001:6001"
    volumes:
      - /app/microService:/data
    networks:
      - springboot_network
    depends_on:  # 配置该容器服务所依赖的容器服务
      - redis
      - mysql

  redis:
    image: redis:6.0.8
    ports:
      - "6379:6379"
    volumes:
      - /app/redis/redis.conf:/etc/redis/redis.conf
      - /app/redis/data:data
    networks:
      - springboot_network
    command: redis-server /etc/redis/redis.conf

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

networks:
  # 创建 springboot_network 网桥网络
  springboot_network:

编写完成docker-compose.yml后，进行语法检查：

# 进行语法检查
docker-compose config -q

如果语法检查没有任何问题，进行创建、启动：

docker-compose up -d

五、Portainer轻量级图形化监控

5.1 Portainer：Docker轻量级可视化工具

Portainer是一款轻量级的应用，它提供了图形化界面，用于方便地管理Docker环境，包括单机环境和集群环境。
Portainer分为开源社区版（CE版）和商用版（BE版/EE版）。

5.2 安装

Portainer也是一个Docker镜像，可以直接使用Docker运行。

# 旧版镜像地址为portainer/portainer，从2022年1月标记为过期
# 新版镜像地址为portainer/portainer-ce

# --restart=always 如果Docker引擎重启了，那么这个容器实例也会在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-ce:2.13.0-alpine

启动之后，便可以在浏览器中进行访问：
http://xxx.xxx.xxx.xxx:9000
首次进来时，需要创建 admin 的用户名（默认admin）、密码（必须满足校验规则，例如portainer.io123）。
选择local管理本地docker，即可看到本地Docker的详细信息，包括其中的镜像（images）、容器（containers）、网络（networks）、容器卷（volumes）、compose编排（stacks）等等。

六、GIC重量级监控

6.1 GIC

通过docker stats 命令可以很方便的查看当前宿主机上所有容器的CPU、内存、网络流量等数据，可以满足一些小型应用。
但是 docker stats 统计结果只能是当前宿主机的全部容器，数据资料是实时的，没有地方存储、没有健康指标过线预警等功能。
CAdvisor（监控收集） + InfluxDB（存储数据） + Granfana（展示图表），合称 CIG。

6.2 CAdvisor

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

6.3 InfluxDB

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

6.4 Granfana

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

6.5 安装部署

容器启动前准备

编写docker-compose.yml服务编排文件

version: '3.1'

volumes:
  grafana_data: {}

services:
  influxdb:
	# tutum/influxdb 相比influxdb多了web可视化视图。但是该镜像已被标记为已过时
    image: tutum/influxdb:0.9
    restart: always
    environment:
      - PRE_CREATE_DB=cadvisor
    ports:
      - "8083:8083"         # 数据库web可视化页面端口
      - "8086:8086"         # 数据库端口
    volumes:
      - ./data/influxdb:/data

  cadvisor:
    image: google/cadvisor:v0.32.0
    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:
    image: grafana/grafana:8.5.2
    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

检查语法

docker-compose config -q

创建并启动容器

docker-compose up -d

容器启动之后：

在浏览器打开InfluxDB数据库的页面： http://xxx.xxx.xxx.xxx:8083，使用命令查看当前数据库中的数据库实例：

SHOW DATABASES

查看其中是否自动创建了我们在配置文件中配置的 cadvisor数据库实例

在浏览器打开CAdvisor页面：http://xxx.xxx.xxx.xxx8080/，查看当前docker中的cpu、内存、网络IO等统计信息
在浏览器打开Grafana页面：http://xxx.xxx.xxx.xxx:3000/，默认用户名密码是：admin/admin。

6.6 Grafana配置

6.6.1 添加数据源

在Configuration（小齿轮）选项卡中，选择Data Sources，添加一个InfluxDB数据源：

name：自定义一个数据源名称，例如InfluxDB
Query Language：查询语言，默认InfluxQL即可
URL：根据compose中的容器服务名连接，http://influxdb:8086
database：我们在InfluxDB中创建的数据库实例，cadvisor
User：InfluxDB的默认用户，root
Password：root
保存并测试，可以连通即可

6.6.2 添加工作台

在Create（加号）选项卡中，选择创建 Dash Board工作台。右上角配置中可以配置创建出来的工作台的标题、文件夹等信息。
在创建出来的工作台中，选择Add panel中的Add a new panel添加一个新的面板。
a. 在右上角Time series（时序图）位置可以切换展示的图表样式（柱状图、仪表盘、表格、饼图等等）
b. 右侧边栏为该图表配置相关信息：标题、描述
c. 图表下方可以配置该图表展示的数据的查询语句，例如：
■ FROM：cpu_usage_total（Grafana会自动获取InfluxDB数据库中的元数据，可以直接选择对应表名）
■ WHERE：添加一个条件，container_name=cig-cadvisor-1
■ ALIAS：配置一个别名，CPU使用情况汇总