2.1 环境要求

  • Golang 1.17
  • DTM
  • Etcd
  • Redis
  • Mysql
  • Prometheus
  • Grafana
  • Jaeger

    2.2 Docker 本地开发环境搭建

    为了方便开发调试，我们使用 Docker 构建本地开发环境。Windows 和 macOS 系统可下载 Docker Desktop 安装使用，具体下载安装方法可自行搜索相关教程。
    这里我们使用 Docker Compose 来编排管理我们的容器，创建如下目录： ```bash gonivinck ├── dtm # DTM 分布式事务管理器 │ ├── config.yml # DTM 配置文件 │ └── Dockerfile ├── etcd # Etcd 服务注册发现 │ └── Dockerfile ├── golang # Golang 运行环境 │ └── Dockerfile ├── grafana # Grafana 可视化数据监控 │ └── Dockerfile ├── jaeger # Jaeger 链路追踪 │ └── Dockerfile ├── mysql # Mysql 服务 │ └── Dockerfile ├── mysql-manage # Mysql 可视化管理 │ └── Dockerfile ├── prometheus # Prometheus 服务监控 │ ├── Dockerfile │ └── prometheus.yml # Prometheus 配置文件 ├── redis # Redis 服务 │ └── Dockerfile ├── redis-manage # Redis 可视化管理 │ └── Dockerfile ├── .env # env 配置 └── docker-compose.yml
  1. <a name="VJZWN"></a>
  2. ### 2.2.1 编写 Dockerfile
  3. 在 go-zero 的微服务中采用 grpc 进行服务间的通信，而 grpc 的编写就需要用到 protoc 和翻译成 go 语言 rpc stub 代码的插件 protoc-gen-go。<br />为了提高开发效率，减少代码的出错率，缩短业务开发的工作量，go-zero 还提供了 goctl 代码生成工具。<br />因此，我们需要将 protoc, protoc-gen-go, goctl, 给提前安装到 golang 的容器中，以便后续使用。<br />所以 golang 容器的 Dockerfile 代码如下：
  4. ```dockerfile
  5. FROM golang:1.17
  7. LABEL maintainer="Ving <ving@nivin.cn>"
  9. ENV GOPROXY https://goproxy.cn,direct
  11. # 安装必要的软件包和依赖包
  12. USER root
  13. RUN sed -i 's/deb.debian.org/mirrors.tuna.tsinghua.edu.cn/' /etc/apt/sources.list && \
  14.     sed -i 's/security.debian.org/mirrors.tuna.tsinghua.edu.cn/' /etc/apt/sources.list && \
  15.     sed -i 's/security-cdn.debian.org/mirrors.tuna.tsinghua.edu.cn/' /etc/apt/sources.list && \
  16.     apt-get update && \
  17.     apt-get upgrade -y && \
  18.     apt-get install -y --no-install-recommends \
  19.     curl \
  20.     zip \
  21.     unzip \
  22.     git \
  23.     vim 
  25. # 安装 goctl
  26. USER root
  27. RUN GOPROXY=https://goproxy.cn/,direct go install github.com/tal-tech/go-zero/tools/goctl@cli
  29. # 安装 protoc
  30. USER root
  31. RUN curl -L -o /tmp/protoc.zip https://github.com/protocolbuffers/protobuf/releases/download/v3.19.1/protoc-3.19.1-linux-x86_64.zip && \
  32.     unzip -d /tmp/protoc /tmp/protoc.zip && \
  33.     mv /tmp/protoc/bin/protoc $GOPATH/bin
  35. # 安装 protoc-gen-go
  36. USER root
  37. RUN go get -u github.com/golang/protobuf/protoc-gen-go@v1.4.0
  39. # $GOPATH/bin添加到环境变量中
  40. ENV PATH $GOPATH/bin:$PATH
  42. # 清理垃圾
  43. USER root
  44. RUN apt-get clean && \
  45.     rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/* && \
  46.     rm /var/log/lastlog /var/log/faillog
  48. # 设置工作目录
  49. WORKDIR /usr/src/code
  51. EXPOSE 8000
  52. EXPOSE 8001
  53. EXPOSE 8002
  54. EXPOSE 8003
  55. EXPOSE 9000
  56. EXPOSE 9001
  57. EXPOSE 9002
  58. EXPOSE 9003

其他服务容器 Dockerfile 无需特殊处理，只要基于现有的镜像即可。

服务 基于的镜像
DTM yedf/dtm
Etcd bitnami/etcd
Mysql mysql:5.7
Redis redis:5.0
Mysql Manage phpmyadmin/phpmyadmin
Redis Manage erikdubbelboer/phpredisadmin
Prometheus bitnami/prometheus
Grafana grafana/grafana
Jaeger jaegertracing/all-in-one:1.28

2.2.2 编写 .env 配置文件

  1. # 设置时区
  2. TZ=Asia/Shanghai
  3. # 设置网络模式
  4. NETWORKS_DRIVER=bridge
  7. # PATHS ##########################################
  8. # 宿主机上代码存放的目录路径
  9. CODE_PATH_HOST=./code
  10. # 宿主机上Mysql Reids数据存放的目录路径
  11. DATA_PATH_HOST=./data
  14. # MYSQL ##########################################
  15. # Mysql 服务映射宿主机端口号，可在宿主机127.0.0.1:3306访问
  16. MYSQL_PORT=3306
  17. MYSQL_USERNAME=admin
  18. MYSQL_PASSWORD=123456
  19. MYSQL_ROOT_PASSWORD=123456
  21. # Mysql 可视化管理用户名称，同 MYSQL_USERNAME
  22. MYSQL_MANAGE_USERNAME=admin
  23. # Mysql 可视化管理用户密码，同 MYSQL_PASSWORD
  24. MYSQL_MANAGE_PASSWORD=123456
  25. # Mysql 可视化管理ROOT用户密码，同 MYSQL_ROOT_PASSWORD
  26. MYSQL_MANAGE_ROOT_PASSWORD=123456
  27. # Mysql 服务地址
  28. MYSQL_MANAGE_CONNECT_HOST=mysql
  29. # Mysql 服务端口号
  30. MYSQL_MANAGE_CONNECT_PORT=3306
  31. # Mysql 可视化管理映射宿主机端口号，可在宿主机127.0.0.1:1000访问
  32. MYSQL_MANAGE_PORT=1000
  35. # REDIS ##########################################
  36. # Redis 服务映射宿主机端口号，可在宿主机127.0.0.1:6379访问
  37. REDIS_PORT=6379
  39. # Redis 可视化管理用户名称
  40. REDIS_MANAGE_USERNAME=admin
  41. # Redis 可视化管理用户密码
  42. REDIS_MANAGE_PASSWORD=123456
  43. # Redis 服务地址
  44. REDIS_MANAGE_CONNECT_HOST=redis
  45. # Redis 服务端口号
  46. REDIS_MANAGE_CONNECT_PORT=6379
  47. # Redis 可视化管理映射宿主机端口号，可在宿主机127.0.0.1:2000访问
  48. REDIS_MANAGE_PORT=2000
  51. # ETCD ###########################################
  52. # Etcd 服务映射宿主机端口号，可在宿主机127.0.0.1:2379访问
  53. ETCD_PORT=2379
  56. # PROMETHEUS #####################################
  57. # Prometheus 服务映射宿主机端口号，可在宿主机127.0.0.1:3000访问
  58. PROMETHEUS_PORT=3000
  61. # GRAFANA ########################################
  62. # Grafana 服务映射宿主机端口号，可在宿主机127.0.0.1:4000访问
  63. GRAFANA_PORT=4000
  66. # JAEGER #########################################
  67. # Jaeger 服务映射宿主机端口号，可在宿主机127.0.0.1:5000访问
  68. JAEGER_PORT=5000
  71. # DTM #########################################
  72. # DTM HTTP 协议端口号
  73. DTM_HTTP_PORT=36789
  74. # DTM gRPC 协议端口号
  75. DTM_GRPC_PORT=36790

2.2.3 编写 docker-compose.yml 配置文件

  1. version: '3.5'
  2. # 网络配置
  3. networks:
  4.   backend:
  5.     driver: ${NETWORKS_DRIVER}
  7. # 服务容器配置
  8. services:
  9.   golang:                                # 自定义容器名称
  10.     build:
  11.       context: ./golang                  # 指定构建使用的 Dockerfile 文件
  12.     environment:                         # 设置环境变量
  13.       - TZ=${TZ}
  14.     volumes:                             # 设置挂载目录
  15.       - ${CODE_PATH_HOST}:/usr/src/code  # 引用 .env 配置中 CODE_PATH_HOST 变量，将宿主机上代码存放的目录挂载到容器中 /usr/src/code 目录
  16.     ports:                               # 设置端口映射
  17.       - "8000:8000"
  18.       - "8001:8001"
  19.       - "8002:8002"
  20.       - "8003:8003"
  21.       - "9000:9000"
  22.       - "9001:9001"
  23.       - "9002:9002"
  24.       - "9003:9003"
  25.     stdin_open: true                     # 打开标准输入，可以接受外部输入
  26.     tty: true
  27.     networks:
  28.       - backend
  29.     restart: always                      # 指定容器退出后的重启策略为始终重启
  31.   etcd:                                  # 自定义容器名称
  32.     build:
  33.       context: ./etcd                    # 指定构建使用的 Dockerfile 文件
  34.     environment:
  35.       - TZ=${TZ}
  36.       - ALLOW_NONE_AUTHENTICATION=yes
  37.     ports:                               # 设置端口映射
  38.       - "${ETCD_PORT}:2379"
  39.     networks:
  40.       - backend
  41.     restart: always
  43.   mysql:
  44.     build:
  45.       context: ./mysql
  46.     environment:
  47.       - TZ=${TZ}
  48.       - MYSQL_USER=${MYSQL_USERNAME}                  # 设置 Mysql 用户名称
  49.       - MYSQL_PASSWORD=${MYSQL_PASSWORD}              # 设置 Mysql 用户密码
  50.       - MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}    # 设置 Mysql root 用户密码
  51.     volumes:
  52.       - ${DATA_PATH_HOST}/mysql:/var/lib/mysql        # 引用 .env 配置中 DATA_PATH_HOST 变量，将宿主机上存放 Mysql 数据的目录挂载到容器中 /var/lib/mysql 目录
  53.     ports:
  54.       - "${MYSQL_PORT}:3306"                          # 设置容器3306端口映射指定宿主机端口
  55.     networks:
  56.       - backend
  57.     restart: always
  59.   redis:
  60.     build:
  61.       context: ./redis
  62.     environment:
  63.       - TZ=${TZ}
  64.     volumes:
  65.       - ${DATA_PATH_HOST}/redis:/data                 # 引用 .env 配置中 DATA_PATH_HOST 变量，将宿主机上存放 Redis 数据的目录挂载到容器中 /data 目录
  66.     ports:
  67.       - "${REDIS_PORT}:6379"                          # 设置容器6379端口映射指定宿主机端口
  68.     networks:
  69.       - backend
  70.     restart: always
  72.   mysql-manage:
  73.     build:
  74.       context: ./mysql-manage
  75.     environment:
  76.       - TZ=${TZ}
  77.       - PMA_ARBITRARY=1
  78.       - MYSQL_USER=${MYSQL_MANAGE_USERNAME}               # 设置连接的 Mysql 服务用户名称
  79.       - MYSQL_PASSWORD=${MYSQL_MANAGE_PASSWORD}           # 设置连接的 Mysql 服务用户密码
  80.       - MYSQL_ROOT_PASSWORD=${MYSQL_MANAGE_ROOT_PASSWORD} # 设置连接的 Mysql 服务 root 用户密码
  81.       - PMA_HOST=${MYSQL_MANAGE_CONNECT_HOST}             # 设置连接的 Mysql 服务 host，可以是 Mysql 服务容器的名称，也可以是 Mysql 服务容器的 ip 地址
  82.       - PMA_PORT=${MYSQL_MANAGE_CONNECT_PORT}             # 设置连接的 Mysql 服务端口号
  83.     ports:
  84.       - "${MYSQL_MANAGE_PORT}:80"                         # 设置容器80端口映射指定宿主机端口，用于宿主机访问可视化web
  85.     depends_on:                                           # 依赖容器
  86.       - mysql                                             # 在 Mysql 服务容器启动后启动
  87.     networks:
  88.       - backend
  89.     restart: always
  91.   redis-manage:
  92.     build:
  93.       context: ./redis-manage
  94.     environment:
  95.       - TZ=${TZ}
  96.       - ADMIN_USER=${REDIS_MANAGE_USERNAME}           # 设置 Redis 可视化管理的用户名称
  97.       - ADMIN_PASS=${REDIS_MANAGE_PASSWORD}           # 设置 Redis 可视化管理的用户密码
  98.       - REDIS_1_HOST=${REDIS_MANAGE_CONNECT_HOST}     # 设置连接的 Redis 服务 host，可以是 Redis 服务容器的名称，也可以是 Redis 服务容器的 ip 地址
  99.       - REDIS_1_PORT=${REDIS_MANAGE_CONNECT_PORT}     # 设置连接的 Redis 服务端口号
  100.     ports:
  101.       - "${REDIS_MANAGE_PORT}:80"                     # 设置容器80端口映射指定宿主机端口，用于宿主机访问可视化web
  102.     depends_on:                                       # 依赖容器
  103.       - redis                                         # 在 Redis 服务容器启动后启动
  104.     networks:
  105.       - backend
  106.     restart: always
  108.   prometheus:
  109.     build:
  110.       context: ./prometheus
  111.     environment:
  112.       - TZ=${TZ}
  113.     volumes:
  114.       - ./prometheus/prometheus.yml:/opt/bitnami/prometheus/conf/prometheus.yml  # 将 prometheus 配置文件挂载到容器里
  115.     ports:
  116.       - "${PROMETHEUS_PORT}:9090"                     # 设置容器9090端口映射指定宿主机端口，用于宿主机访问可视化web
  117.     networks:
  118.       - backend
  119.     restart: always
  121.   grafana:
  122.     build:
  123.       context: ./grafana
  124.     environment:
  125.       - TZ=${TZ}
  126.     ports:
  127.       - "${GRAFANA_PORT}:3000"                        # 设置容器3000端口映射指定宿主机端口，用于宿主机访问可视化web
  128.     networks:
  129.       - backend
  130.     restart: always
  132.   jaeger:
  133.     build:
  134.       context: ./jaeger
  135.     environment:
  136.       - TZ=${TZ}
  137.     ports:
  138.       - "${JAEGER_PORT}:16686"                        # 设置容器16686端口映射指定宿主机端口，用于宿主机访问可视化web
  139.     networks:
  140.       - backend
  141.     restart: always
  143.   dtm:
  144.     build:
  145.       context: ./dtm
  146.     environment:
  147.       - TZ=${TZ}
  148.     entrypoint:
  149.       - "/app/dtm/dtm"
  150.       - "-c=/app/dtm/configs/config.yaml"
  151.     volumes:
  152.       - ./dtm/config.yml:/app/dtm/configs/config.yaml # 将 dtm 配置文件挂载到容器里
  153.     ports:
  154.       - "${DTM_HTTP_PORT}:36789"
  155.       - "${DTM_GRPC_PORT}:36790"
  156.     networks:
  157.       - backend
  158.     restart: always

2.2.4 构建与运行

  • 使用 docker-compose 命令来构建和启动运行我们的服务容器，在根目录执行如下命令：

    1. $ docker-compose up -d

  • 容器构建中

2 环境搭建 - 图1

  • 在 Windows 系统容器构建中出现如下图所示，请选择 Share it 这将允许 Windows 的文件目录挂载到容器目录中。

2 环境搭建 - 图2

  • 容器已启动运行

2 环境搭建 - 图3
2 环境搭建 - 图4

2.2.5 容器说明

容器名称 暴露端口 host地址 说明
golang 8000:8000
8001:8001
8002:8002
8003:8003
9000:9000
9001:9001
9002:9002
9003:9003		 golang 在生产环境中微服务一般都是集群部署，可能一个微服务一台服务器，也可能一个微服务一个容器。为了方便开发调试，我们将在 golang 容器中启动所有微服务，并为它们分配监听不同的端口号以示区分。
80：开头的端口号我们将用于 api 服务
90：开头的端口号我们将用于 rpc 服务
dtm 36789:36789
36790:36790		 dtm dtm 的 http 协议和 grpc 协议服务端口号，供客户端交互使用。
此项目中我们只在 Docker 内部容器之间访问使用，所以也可以不暴露端口号给宿主机
etcd 2379:2379 etcd Etcd http api 服务端口号，供客户端交互使用。
此项目中我们只在 Docker 内部容器之间访问使用，所以也可以不暴露端口号给宿主机
mysql 3306:3306 mysql Mysql 服务默认端口号，宿主机可通过 127.0.0.1:3306 进行数据库的连接
redis 6379:6379 redis Redis 服务默认端口号，宿主机可通过 127.0.0.1:6379 进行数据库的连接
mysql-manage 1000:80 mysql-manage phpMyAdmin web 服务端口号，可以在宿主机 127.0.0.1:1000 访问
redis-manage 2000:80 redis-manage phpRedisAdmin web 服务端口号，可以在宿主机 127.0.0.1:2000 访问
prometheus 3000:9090 prometheus Prometheus web 服务端口号，可以在宿主机 127.0.0.1:3000 访问
grafana 4000:3000 grafana Grafana web 服务端口号，可以在宿主机 127.0.0.1:4000 访问
jaeger 5000:16686 jaeger Jaeger web 服务端口号，可以在宿主机 127.0.0.1:5000 访问

2.2.6 访问验证

  • Mysql 访问验证

2 环境搭建 - 图5

  • Redis 访问验证

2 环境搭建 - 图6

  • Prometheus 访问验证

2 环境搭建 - 图7

  • Grafana 访问验证

2 环境搭建 - 图8

  • Jaeger 访问验证

2 环境搭建 - 图9
项目地址：github