云原生 - Docker_docker知识点-CSDN博客

本文链接：https://blog.csdn.net/sunyoona/article/details/130318751

Docker

第 1 章 Docker 简介

1.1 Docker 和虚拟机的区别

传统虚拟机技术需要虚拟出一套硬件，然后在上面运行一个完整的操作系统，在该操作系统上再运行所需应用进程；而 docker 容器内的应用程序直接使用宿主机的硬件资源。因此 docker 相比虚拟机更为轻便
docker 启动时间更快(秒级)，而虚拟机需要数分钟
docker 占的空间很小(MB 级)，虚拟机一般要 GB 级空间
docker 的镜像提供了除内核外完整的运行时环境，确保应用运行环境一致性
开发人员可以通过 Dockerfile 定制镜像，并结合持续集成(CI，Continuous Integration)系统进行集成测试；运维人员可以直接在生产环境中快速部署该镜像，并结合持续部署(CD，Continuous Deployment)系统进行自动部署

1.2 Docker 的三个基本概念

镜像（Image）：提供运行容器所需的数据文件的一组文件系统

镜像相当于 Linux 系统中的 root 文件系统。

镜像是一层一层叠加构建的。每安装一个软件，就会在现有镜像的基础上增加一层，最后构成整个镜像。

容器（Container）：由 docker 镜像创建的运行实例

容器与镜像的关系类似于面向对象编程中的对象与类。

容器的实质是进程，但与宿主机中的进程不同。容器运行在隔离的环境中(独立的命名空间)，拥有自己的 root 文件系统、网络配置、进程空间。

仓库（Dokcer Repository）：包含镜像的仓库，docker 的默认仓库是 Docker Hub 公共仓库，k8s 使用的镜像仓库是 Google 的 Google Container Registry

1.3 Docker 镜像层 / 容器层

docker 使用 Union FS 文件系统对镜像进行分层。当容器启动时，一个新的可写层被加载到镜像的顶部，称为容器层，容器层之下都是镜像层。镜像都是只读的，容器层是可写的，所有对容器的改动都发生在容器层。

虚悬镜像即仓库名和版本标签都是 none 的镜像。有时候新旧镜像同名，旧镜像的名称和标签都被取消，一般来说虚悬镜像可以随意删除：

docker image prune

1.4 Linux 下安装 Docker CE

1.4.1 Centos7

登录阿里云镜像 docker-ce 镜像，复制 docker-ce.repo 文件链接地址：

https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

在虚拟机上进入 /etc/yum.repos.d 目录，下载 docker-ce.repo 文件：

cd /etc/yum.repos.d
wget https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

安装 docker 并启动：

yum install -y docker-ce
systemctl start docker
systemctl enable docker

配置镜像加速器，登录阿里云容器镜像加速器：

vim /etc/docker/daemon.json，然后添加以下三行内容：

{
  "registry-mirrors": ["https://3li81rlf.mirror.aliyuncs.com"]
}

然后打包执行：

systemctl daemon-reload
systemctl restart docker
docker --version

1.4.2 Centos7 / Ubuntu / Debian 脚本安装命令

官方提供了脚本安装命令：

curl -fsSL get.docker.com -o get-docker.sh
sudo sh get-docker.sh --mirror Aliyun
sudo systemctl enable docker
sudo systemctl start docker

第 2 章 Docker 常用命令

2.1 启动停止 docker

systemctl start docker    # 启动
systemctl stop docker     # 停止

2.2 镜像命令

2.2.1 docker images

docker images    # 列出本地主机上的镜像
docker images -a # 列出本地主机上的镜像，包括历史镜像

2.2.2 docker search / pull

docker search <image-name>     # 在镜像仓库中寻找镜像
docker pull <image-name>:<tag> # 从镜像仓库中拉取镜像，没有写 tag 默认拉取最新的

2.2.3 docker rmi 删除镜像

docker rmi -f <image-id> # 根据 ID 删除镜像

如果想要删除所有仓库名为 redis 的镜像：

docker rmi $(docker images -q redis)

2.3 容器命令

2.3.1 docker run 启动容器（⭐）

docker run [OPTIONS] <container-id> [COMMAND] [ARG...]

OPTIOINS：

–name=<容器名>：指定容器名称

-d：后台守护式运行容器（启动 MySQL、Redis）

-it：前台交互式运行容器，并重新分配一个伪输入终端（启动 Ubuntu、Centos）

-p <宿主机端口>:<Dokcer端口>：指定端口

2.3.2 docker ps 查看运行容器（⭐）

docker ps      # 查看正在运行的容器
docker ps -a   # 查看运行过的所有容器

2.3.3 exit / Ctrl + p + q 退出容器

exit 退出：容器停止，退出
Ctrl + p + q：容器不会停止，退出

2.3.4 docker exec/ attach 重新进入正在运行的容器（⭐）

docker exec -it <container-id> /bin/bash  
docker attach <container-id>

exec（推荐使用）：在容器中打开新的终端，启动新的进程。用 exit 退出时不会导致容器停止

attach：直接进入容器启动终端，不会启动新的进程。用 exit 退出时会导致容器停止

2.3.5 docker start / stop 启动 / 停止容器

docker start <container-id>     # 重启容器
docker stop <container-id>      # 停止容器
docker stop $(docker ps -a -q)  # 停止所有容器

2.3.6 docker rm 删除已停止的容器

docker rm <container-id>
docker rm $(docker ps -a -q)  # 删除所有容器

2.3.7 docker cp 拷贝容器内文件到主机

docker cp <container-id>:<container-path> <localhost-path>

2.4 推送仓库命令

2.4.1 推送到 dockerhub

docker login
# 输入账号名和密码

docker images
# 查看要推送的仓库名，将其改为标准格式
docker tag <repo-name> <username>/<repo-name>:tag

docker push <username>/<repo-name>:tag

2.4.2 推送本地私有仓库

docker pull registry
docker run -d -v /data/registry:/var/lib/registry -p 5000:5000 --restart=always --name registry registry

vim /etc/docker/daemon.json

{
    "insecure-registries":[
        "<ip>:5000"
    ]
}

# 查看要推送的仓库名，将其改为标准格式
docker tag <repo-name> <ip:5000>/<repo-name>:tag
docker push <ip:5000>/<repo-name>:tag

第 3 章 Docker 数据卷

3.1 数据卷含义（⭐）

使用 Docker 容器的时候，会产生一系列的数据文件，这些数据文件在删除 Docker 容器时是会消失的。我们希望在运行过程中产生的部分数据文件是可持久化（可备份）的，并且容器之间能够实现数据共享。

数据卷用于解决以上的两个问题。数据卷就是目录或者文件，存在于一个或多个的容器中，由 docker 挂载到容器，但不属于 Union FS。数据卷的设计目的就是数据的持久化，docker 不会在容器删除时删除其挂载的数据卷。

3.2 运行带数据卷的容器

Docker 官方推荐使用目录挂载：

docker run -it --privileged=true -v/<localhost-absolute_path>:/<container-path> --name="<container-name>" <image-name>

我们可以通过 docker inspect 命令查看数据卷是否挂载成功：

3.3 删除无主的数据卷

docker volume prune

第 4 章 Docker 数据库安装

注意先关闭防火墙。

4.1 安装 MySQL

4.1.1 MySQL 单机

docker pull mysql:5.7

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

修改 Docker 上 MySQL 的字符集，vim /sy/mysql/conf/my.cnf，写入以下内容：

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

重启 MySQL 容器即可完成配置：

docker restart mysql
# 进入容器
docker exec -it mysql /bin/bash

mysql -uroot -p

<输入你的密码>

4.1.2 MySQL 主从复制

mysql-master

新建主机：

docker pull mysql:5.7

docker run -d -p 3307:3306 --privileged=true \
           -v /sy/mysql-master/log:/var/log/mysql \
           -v /sy/mysql-master/data:/var/lib/mysql \
           -v /sy/mysql-master/conf:/etc/mysql/conf.d \
           -e MYSQL_ROOT_PASSWORD=123 \
           --name mysql-master \
           mysql:5.7
              
docker ps

vim /sy/mysql-master/conf/my.cnf，添加以下内容：

[mysqld]
server_id=101
binlog-ignore-db=mysql
log-bin=mall-mysql-bin
binlog_cache_size=1M
binlog_format=mixed
expire_logs_days=7
slave_skip_errors=1062

重启 mysql-master 容器并进入验证：

docker restart mysql-master

docker exec -it mysql-master /bin/bash

mysql -uroot -p

<输入你的密码>

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

mysql> create user 'slave'@'%' identified by '123';

mysql> grant replication slave, replication client on *.* to 'slave'@'%';

mysql-slave

开启新的终端来新建从机：

docker run -d -p 3308:3306 --privileged=true \
           -v /sy/mysql-slave/log:/var/log/mysql \
           -v /sy/mysql-slave/data:/var/lib/mysql \
           -v /sy/mysql-slave/conf:/etc/mysql/conf.d \
           -e MYSQL_ROOT_PASSWORD=123 \
           --name mysql-slave \
           mysql:5.7
              
docker ps

vim /sy/mysql-slave/conf/my.cnf，添加以下内容：

[mysqld]
server_id=102
binlog-ignore-db=mysql
log-bin=mall-mysql-slave-bin
binlog_cache_size=1M
binlog_format=mixed
expire_logs_days=7
slave_skip_errors=1062
relay_log=mall-mysql-relay-bin
log_slave_updates=1
read_only=1

重启 mysql-slave 容器并进入验证：

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

mysql -uroot -p

<输入你的密码>

回到主机终端，在主机实例内输入命令：

mysql> show master status;

进入从机终端，在从机实例内输入命令：

mysql> change master to master_host='192.168.239.128',master_user='slave',master_password='123',master_port=3307,master_log_file='mall-mysql-bin.000001',master_log_pos=617,master_connect_retry=30;
                        
mysql> show slave status \G;

在从机实例内开启主从同步：

mysql> start slave;

mysql> show slave status \G;

验证主从复制

主机实例中插入数据：

mysql> create database db01;
mysql> use db01;
mysql> create table t1(id int,name varchar(20));
mysql> insert into t1 values(1,'zhang3');
mysql> select * from t1;

从机实例中查看主机数据：

mysql> use db01;

4.2 安装 Redis

4.2.1 Redis 单机

将 Linux 上的 redis 配置文件复制到新创建的 /app/redis 下：

docker pull redis：7.0.8  # 一定注意和 Linux 中已有的 Redis 版本一致，否则配置文件冲突

docker run -p 6379:6379 --name redis \
            --privileged=true 
            -v /app/redis/redis.conf:/etc/redis/redis.conf \
            -v /app/redis/data:/data \
            -d redis:7.0.8 \
            redis-server /etc/redis/redis.conf

docker ps

docker exec -it redis /bin/bash

redis-cli

4.2.2 Redis 三主三从

首先 Linux 上关闭防火墙。

新建 6 个 Redis 实例：

docker run -d --name redis_1 --net host --privileged=true -v /data/redis/share/redis_1:/data redis:7.0.8 --cluster-enabled yes --appendonly yes --port 6381

docker run -d --name redis_2 --net host --privileged=true -v /data/redis/share/redis_2:/data redis:7.0.8 --cluster-enabled yes --appendonly yes --port 6382

docker run -d --name redis_3 --net host --privileged=true -v /data/redis/share/redis_3:/data redis:7.0.8 --cluster-enabled yes --appendonly yes --port 6383

docker run -d --name redis_4 --net host --privileged=true -v /data/redis/share/redis_4:/data redis:7.0.8 --cluster-enabled yes --appendonly yes --port 6384

docker run -d --name redis_5 --net host --privileged=true -v /data/redis/share/redis_5:/data redis:7.0.8 --cluster-enabled yes --appendonly yes --port 6385

docker run -d --name redis_6 --net host --privileged=true -v /data/redis/share/redis_6:/data redis:7.0.8 --cluster-enabled yes --appendonly yes --port 6386

docker ps

构建集群关系：

docker exec -it redis_1 /bin/bash

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

我这里主机是 6381、8382、6383，从机 6384、6385、6386：

查看槽位分配：

redis-cli --cluster check 192.168.239.128:6381

查看主从关系：

redis-cli -p 6381 -c
127.0.0.1:6381> cluster info
127.0.0.1:6381> cluster nodes

我这里 6381 下的从机是 6385，6382 下的从机是 6386，6383 下的从机是 6384：

4.2.3 主从扩容

从之前的 3 主 3 从变成 4 主 4 从。新建 2 个 Redis 实例：

docker run -d --name redis_7 --net host --privileged=true -v /data/redis/share/redis_7:/data redis:7.0.8 --cluster-enabled yes --appendonly yes --port 6387

docker run -d --name redis_8 --net host --privileged=true -v /data/redis/share/redis_8:/data redis:7.0.8 --cluster-enabled yes --appendonly yes --port 6388

docker ps

进入 6387，加入原集群：

docker exec -it redis_7 /bin/bash

redis-cli --cluster add-node 192.168.239.128:6387 192.168.239.128:6381

重新分配槽号：

redis-cli --cluster reshard 192.168.239.128:6381

# 输入 4096
# 输入 [6387 的 id]
# 输入 all
# 输入 yes

redis-cli --cluster check 192.168.239.128:6381

6387 分配的是 3 个新的不连续的区间，来自之前三个主机各自匀出来的一部分槽位：

再为主机 6387 分配从机 6388：

redis-cli --cluster add-node 192.168.239.128:6388 192.168.239.128:6387 --cluster-slave --cluster-master-id [6387的id]

redis-cli --cluster check 192.168.239.128:6381

4.2.4 主从缩容

先删除从机 6388（先获取 6388 的 id）：

redis-cli --cluster del-node 192.168.239.128:6388 [6388的id]

将 6387 的槽号重新分配给 6381：

redis-cli --cluster reshard 192.168.239.128:6381

# 输入 4096
# 输入 [6381 的 id]

# 输入 [6387 的 id]
# 输入 done

# 输入 yes

redis-cli --cluster check 192.168.239.128:6381

再将 6387 删除：

redis-cli --cluster del-node 192.168.239.128:6387 [6387的id]

redis-cli --cluster check 192.168.239.128:6381

第 5 章 DockerFile

DockerFile 是定制构建 Docker 镜像的文本文件，是由若干条构建镜像所需指令和参数构成的脚本。

5.1 DockerFile 保留字指令

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

保留字指令	作用
FROM	指定基础镜像；如果不以任何镜像为基础写 FROM scratch。必须写在第一条
MAINTAINER	镜像维护者姓名和邮箱
RUN	在 build 时运行，用于构建容器
EXPOSE	当前容器对外暴露端口
WORKDIR	创建容器后，终端默认登录进来的工作目录
USER	默认为 root
ENV	设置环境变量
ADD	将宿主机镜像拷贝进镜像且自动解压 tar 包
COPY	将宿主机文件或目录拷贝进镜像，不会自动解压缩（文件复制）
VOLUME	容器数据卷，用于容器持久化
CMD	指定容器启动后需要干的事情，多个 CMD 指令只会有最后一个生效，如果 docker run 后带命令行参数（如 /bin/bash），那么 CMD 指令会被该参数覆盖
ENTRYPOINT	指定容器启动后需要干的事情，如果 docker run 后带命令行参数，ENTRYPOINT 指令不会被覆盖，且这些命令行参数传参给 ENTRYPOINT 指令指定的程序

当指定 ENTRYPOINT 后，CMD 不再是直接运行命令，而是将 CMD 后面的内容传参给 ENTRYPOINT 指令，即变成 ENTRYPOINT CMD 指令。

案例理解：DockerFile 构建 nginx:test 镜像：

FROM nginx
...
ENTRYPOINT ["nginx", "-c"]
CMD ["/etc/nginx/nginx.conf"]

相当于在命令行中输入：

docker run nginx -c /etc/nginx/nginx.conf

5.2 RUN / CMD / ENTRYPOINT 执行命令格式

5.2.1 shell 格式

RUN yum -y install vim

5.2.2 exec 格式

exec 格式按照 json 数组格式解析，使用双引号包含参数：

RUN ["可执行文件","参数1","参数2"]

5.3 定制编写镜像

要求 Centos7 镜像带有 vim + ifconfig + jdk8。

5.3.1 创建 Dockerfile 文件

下载 jdk-8u192-linux-x64.tar.gz 到 /opt 目录下。在 /opt 目录下创建 Dockerfile 文件（DockerFile 文件尽量与下载文件在一个文件夹下）：

FROM centos:7
MAINTAINER sy<sy@163.com>
ENV MYPATH /usr/local
WORKDIR $MYPATH
RUN yum -y install vim \
    && yum -y install net-tools \
    && yum -y install glibc.i686
    && mkdir /usr/local/java
ADD jdk-8u192-linux-x64.tar.gz /usr/local/java/
ENV JAVA_HOME /usr/local/java/jdk1.8.0_192
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 /bin/bash

5.3.2 构建新镜像

docker build -t centosjava8:1.5 .

# 等待下载完毕
docker images

5.3.3 镜像构建上下文

如果注意可以看到 docker build 命令最后有个.存在，.表示当前目录，指定的是镜像构建的上下文。因为 docker 在运行时分为服务端守护进程和客户端工具，我们在客户端通过一系列 API 操作服务器远程服务端（C/S 服务架构）。

所以我们在 docker build 构建镜像时，并非在本地客户端构建，而是在服务端中构建。我们需要指定上下文路径，这样 docker build 命令会将该路径下所有内容打包上传给服务端。

5.4 多阶段构建

在 Dockerfile 中使用多个 FROM 指令，每个 FROM 指令都可以使用不同的基础镜像，是一个独立的子构建阶段。

第 6 章 Docker compose

在 Linux 根目录新建一个 Prod 目录，用于各种服务的 Docker compose 文件编写和启动。如果想启动多个服务，只需要相互结合一下写成 docker-compose.yaml 统一启动即可。

6.1 启动 mysql

6.1.1 编写 mysql.yaml

version: '3.9'
services:
  mysql:
    image: mysql:latest
    container_name: mysql
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: test
      MYSQL_USER: sy
      MYSQL_PASSWORD: root
    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:
      - backend
    command:
      --character-set-server=utf8mb4
      --collation-server=utf8mb4_general_ci
      --explicit_defaults_for_timestamp=true
      --default-authentication-plugin=caching_sha2_password

networks:
  backend:
    name: backend

6.1.2 启动 mysql.yaml

docker compose -f mysql.yaml up -d

6.2 启动 redis

6.2.1 编写 redis.yaml

version: '3.9'
services:
  redis:
    image: redis:latest
    container_name: redis
    restart: always
    ports:
      - "6379:6379"
    networks:
      - backend

networks:
  backend:
    name: backend

6.2.2 启动 redis.yaml

docker compose -f redis.yaml up -d

6.3 启动 kafka

6.3.1 编写 kafka.yaml

version: '3.9'
services:
  zookeeper:
    image: bitnami/zookeeper:latest
    container_name: zookeeper
    restart: always
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000   # ZooKeeper 服务器与客户端心跳时间，单位为毫秒
    networks:
      - backend
      
  kafka:
    image: 'bitnami/kafka:latest'
    environment:
      ALLOW_PLAINTEXT_LISTENER: yes                 # 允许使用 PLAINTEXT 侦听器
      KAFKA_CFG_ZOOKEEPER_CONNECT: zookeeper:2181   # zookeeper 的端口
    networks:
      - backend
      
  kafka-ui:
    image: provectuslabs/kafka-ui:latest
    container_name:  kafka-ui
    restart: always
    depends_on:
      - kafka
    ports:
      - "8080:8080"
    environment:
      KAFKA_CLUSTERS_0_NAME: dev                      # kafka 集群 0 的名称
      KAFKA_CLUSTERS_0_BOOTSTRAPSERVERS: kafka:9092   # kafka 集群 0 的访问端口
    networks:
      - backend
  
networks:
  backend:
    name: backend

6.3.2 启动 kafka.yaml

docker compose -f kafka.yaml up -d

6.4 启动 prometheus

6.4.1 编写 prometheus.yaml

设置 prometheus 能监控的服务：

global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'redis'
    static_configs:
      - targets: ['redis:6379']

  - job_name: 'kafka'
    static_configs:
      - targets: ['kafka:9092']

6.4.2 编写 docker-compose.yaml

version: '3.9'
services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    restart: always
    volumes:
      - ./prometheus.yaml:/etc/prometheus/prometheus.yaml
    ports:
      - "9090:9090"
    networks:
      - backend

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    restart: always
    depends_on:
      - prometheus
    ports:
      - "3000:3000"
    networks:
      - backend

networks:
  backend:
    name: backend

6.4.3 启动 docker-compose.yaml

docker compose -f docker-compose.yaml up -d

6.5 启动

第 7 章 Docker 监控工具

7.1 轻量可视化工具 Portainer

Portainer 是一款轻量级的应用给，提供了图形化界面方便地管理 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

 docker ps

第一次登录需要创建 admin，在浏览器访问：9000

在 Portainer 上安装 nginx 容器：

7.2 容器监控 CIG

CIG：CAdvisor 监控收集 + InfluxDB 存储数据 + Granfana 展示图表。

在 /mydocker/CIG 目录下新建 docker-compose.yml：

version: "3.1"
volumes:
        grafana_data: {}

services: 
        influxdb: 
                image: tutum/influxdb:0.9 
                container_name: ms01 
                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=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

检查语法错误（没有任何返回就没有错误）：

docker-compose config -q

运行 docker-compose.yml 文件：

docker-compose up -d

docker ps

测试，浏览器分别输入：

http://192.168.239.128:8080
http://192.168.239.128:8083
http://192.168.239.128:3000

在 Grafana 界面我们先配置数据源：

添加 panel：