# ThingsBoard 11个自身镜像打包详细分析

## 1. 概述

本文档详细分析 ThingsBoard 的 11 个自身镜像是如何从源码打包构建的。所有镜像的构建配置都在 `msa/` 目录下，使用 Maven + Dockerfile 的方式构建。

## 2. 构建架构总览

### 2.1 构建流程

```
源码模块 → Maven 编译 → DEB/JAR 包 → Dockerfile 构建 → Docker 镜像
```

### 2.2 构建工具

- **Maven**: 项目构建和依赖管理
- **dockerfile-maven-plugin**: Docker 镜像构建插件（Spotify）
- **Docker**: 容器构建工具

### 2.3 基础镜像

ThingsBoard 镜像使用两种基础镜像：

1. **Java 服务镜像**: `thingsboard/openjdk17:bookworm-slim`
   - 用于：tb-node、传输服务、vc-executor、edqs
   
2. **Node.js 服务镜像**: `thingsboard/node:22.18.0-bookworm-slim`
   - 用于：tb-web-ui、tb-js-executor

## 3. 11个镜像详细分析

### 3.1 镜像1: thingsboard/tb-node

**用途**: 核心服务和规则引擎服务（共用同一个镜像）

**源码位置**:
- 应用源码: `application/`
- Docker 构建: `msa/tb-node/`

**构建流程**:

1. **Maven 配置** (`msa/tb-node/pom.xml`):
   ```xml
   <!-- 依赖 application 模块的 DEB 包 -->
   <dependency>
       <groupId>org.thingsboard</groupId>
       <artifactId>application</artifactId>
       <classifier>deb</classifier>
       <type>deb</type>
   </dependency>
   ```

2. **构建步骤**:
   - `maven-dependency-plugin`: 复制 DEB 包到 `target/` 目录
   - `maven-resources-plugin`: 复制 Dockerfile 和启动脚本到 `target/` 目录
   - `dockerfile-maven-plugin`: 执行 Docker 构建

3. **Dockerfile** (`msa/tb-node/docker/Dockerfile`):
   ```dockerfile
   FROM thingsboard/openjdk17:bookworm-slim
   
   COPY logback.xml start-tb-node.sh ${pkg.name}.deb /tmp/
   
   RUN chmod a+x /tmp/*.sh \
       && mv /tmp/start-tb-node.sh /usr/bin && \
       (yes | dpkg -i /tmp/${pkg.name}.deb) && \
       rm /tmp/${pkg.name}.deb && \
       mv /tmp/logback.xml ${pkg.installFolder}/conf && \
       chown -R ${pkg.user}:${pkg.user} ${pkg.installFolder}/conf/logback.xml && \
       (systemctl --no-reload disable --now ${pkg.name}.service > /dev/null 2>&1 || :) && \
       chown -R ${pkg.user}:${pkg.user} /tmp && \
       chmod 555 ${pkg.installFolder}/bin/${pkg.name}.jar
   
   USER ${pkg.user}
   CMD ["start-tb-node.sh"]
   ```

4. **关键文件**:
   - DEB 包: `thingsboard-{version}-boot.deb` (来自 `application/` 模块)
   - 启动脚本: `start-tb-node.sh`
   - 日志配置: `logback.xml`

5. **服务区分**:
   - 通过环境变量 `TB_SERVICE_TYPE` 区分：
     - `TB_SERVICE_TYPE=tb-core` → 核心服务
     - `TB_SERVICE_TYPE=tb-rule-engine` → 规则引擎服务

**构建命令**:
```bash
mvn clean install -DskipTests -Ddockerfile.skip=false --projects msa/tb-node --also-make
```

---

### 3.2 镜像2-6: 传输服务镜像（5个）

#### 3.2.1 thingsboard/tb-mqtt-transport

**源码位置**:
- 传输模块: `transport/mqtt/`
- Docker 构建: `msa/transport/mqtt/`

**构建流程**:

1. **Maven 配置** (`msa/transport/mqtt/pom.xml`):
   ```xml
   <dependency>
       <groupId>org.thingsboard.transport</groupId>
       <artifactId>mqtt</artifactId>
       <classifier>deb</classifier>
       <type>deb</type>
   </dependency>
   ```

2. **Dockerfile** (`msa/transport/mqtt/docker/Dockerfile`):
   ```dockerfile
   FROM thingsboard/openjdk17:bookworm-slim
   
   COPY start-tb-mqtt-transport.sh ${pkg.name}.deb /tmp/
   
   RUN chmod a+x /tmp/*.sh \
       && mv /tmp/start-tb-mqtt-transport.sh /usr/bin && \
       (yes | dpkg -i /tmp/${pkg.name}.deb) && \
       rm /tmp/${pkg.name}.deb && \
       (systemctl --no-reload disable --now ${pkg.name}.service > /dev/null 2>&1 || :) && \
       chmod 555 ${pkg.installFolder}/bin/${pkg.name}.jar
   
   USER ${pkg.user}
   CMD ["start-tb-mqtt-transport.sh"]
   ```

#### 3.2.2 thingsboard/tb-http-transport

**构建位置**: `msa/transport/http/`

**Dockerfile**: 与 MQTT 类似，使用 `tb-http-transport.deb` 包

#### 3.2.3 thingsboard/tb-coap-transport

**构建位置**: `msa/transport/coap/`

**Dockerfile**: 与 MQTT 类似，使用 `tb-coap-transport.deb` 包

#### 3.2.4 thingsboard/tb-lwm2m-transport

**构建位置**: `msa/transport/lwm2m/`

**Dockerfile**: 与 MQTT 类似，使用 `tb-lwm2m-transport.deb` 包

#### 3.2.5 thingsboard/tb-snmp-transport

**构建位置**: `msa/transport/snmp/`

**Dockerfile**: 与 MQTT 类似，使用 `tb-snmp-transport.deb` 包

**传输服务镜像共同特点**:
- ✅ 都使用 `thingsboard/openjdk17:bookworm-slim` 基础镜像
- ✅ 都依赖对应的传输模块 DEB 包
- ✅ 都使用相同的构建模式（DEB 包 + 启动脚本）
- ✅ 都使用 `dockerfile-maven-plugin` 构建

**构建命令**:
```bash
# 构建所有传输服务
mvn clean install -DskipTests -Ddockerfile.skip=false --projects msa/transport --also-make

# 构建单个传输服务
mvn clean install -DskipTests -Ddockerfile.skip=false --projects msa/transport/mqtt --also-make
```

---

### 3.3 镜像7: thingsboard/tb-web-ui

**用途**: Web UI 前端服务

**源码位置**:
- 前端源码: `ui-ngx/`
- Docker 构建: `msa/web-ui/`

**构建流程**:

1. **Maven 配置** (`msa/web-ui/pom.xml`):
   ```xml
   <!-- 依赖 ui-ngx 模块的 JAR 包（包含前端静态资源） -->
   <dependency>
       <groupId>org.thingsboard</groupId>
       <artifactId>ui-ngx</artifactId>
       <type>jar</type>
   </dependency>
   ```

2. **构建步骤**:
   - `frontend-maven-plugin`: 安装 Node.js 和 Yarn（用于本地开发）
   - `maven-dependency-plugin`: 解压 `ui-ngx` JAR 包，提取前端静态资源
   - `maven-resources-plugin`: 复制源代码和配置文件
   - `dockerfile-maven-plugin`: 执行 Docker 构建

3. **Dockerfile** (`msa/web-ui/docker/Dockerfile`):
   ```dockerfile
   FROM thingsboard/node:22.18.0-bookworm-slim
   
   ENV NODE_ENV production
   ENV DOCKER_MODE true
   
   COPY start-web-ui.sh /tmp/
   
   WORKDIR ${pkg.installFolder}
   
   COPY ["src/package.json", "src/yarn.lock", "./"]
   COPY package/linux/conf ./conf
   COPY package/linux/conf ./config
   COPY web ./web          # 前端静态资源（从 ui-ngx JAR 解压）
   COPY src/config ./config
   COPY src/server.js ./
   
   RUN chmod a+x /tmp/*.sh \
       && mv /tmp/start-web-ui.sh /usr/bin \
       && chown -R node:node ${pkg.installFolder} \
       && yarn install --production --non-interactive \
       && yarn cache clean --all
   
   USER node
   CMD ["start-web-ui.sh"]
   ```

4. **关键特点**:
   - ✅ 使用 Node.js 基础镜像（不是 Java）
   - ✅ 直接复制源代码（不使用 DEB 包）
   - ✅ 前端静态资源来自 `ui-ngx` JAR 包
   - ✅ 在容器内安装 Node.js 依赖

**构建命令**:
```bash
mvn clean install -DskipTests -Ddockerfile.skip=false --projects msa/web-ui --also-make
```

---

### 3.4 镜像8: thingsboard/tb-js-executor

**用途**: JavaScript 执行器服务

**源码位置**:
- 源码: `msa/js-executor/src/`
- Docker 构建: `msa/js-executor/`

**构建流程**:

1. **Maven 配置** (`msa/js-executor/pom.xml`):
   - 使用 `frontend-maven-plugin` 管理 Node.js 和 Yarn
   - 使用 `maven-resources-plugin` 复制源代码

2. **Dockerfile** (`msa/js-executor/docker/Dockerfile`):
   ```dockerfile
   FROM thingsboard/node:22.18.0-bookworm-slim
   
   ENV NODE_ENV production
   ENV DOCKER_MODE true
   
   COPY start-js-executor.sh /tmp/
   
   WORKDIR ${pkg.installFolder}
   
   COPY ["src/package.json", "src/yarn.lock", "./"]
   COPY package/linux/conf ./conf
   COPY package/linux/conf ./config
   COPY src/api ./api
   COPY src/queue ./queue
   COPY src/config ./config
   COPY src/server.js ./
   
   RUN chmod a+x /tmp/*.sh \
       && mv /tmp/start-js-executor.sh /usr/bin \
       && chown -R node:node ${pkg.installFolder} \
       && yarn install --production --non-interactive \
       && yarn cache clean --all
   
   USER node
   CMD ["start-js-executor.sh"]
   ```

3. **关键特点**:
   - ✅ 使用 Node.js 基础镜像
   - ✅ 直接复制 TypeScript/JavaScript 源代码
   - ✅ 在容器内安装 npm 依赖
   - ✅ 不使用 DEB 包

**构建命令**:
```bash
mvn clean install -DskipTests -Ddockerfile.skip=false --projects msa/js-executor --also-make
```

---

### 3.5 镜像9: thingsboard/tb-vc-executor

**用途**: 版本控制执行器服务

**源码位置**:
- Java 源码: `msa/vc-executor/`
- Docker 构建: `msa/vc-executor-docker/`

**构建流程**:

1. **Maven 配置** (`msa/vc-executor-docker/pom.xml`):
   ```xml
   <dependency>
       <groupId>org.thingsboard.msa</groupId>
       <artifactId>vc-executor</artifactId>
       <classifier>deb</classifier>
       <type>deb</type>
   </dependency>
   ```

2. **Dockerfile** (`msa/vc-executor-docker/docker/Dockerfile`):
   ```dockerfile
   FROM thingsboard/openjdk17:bookworm-slim
   
   ENV DEBIAN_FRONTEND=noninteractive
   RUN apt-get update \
       && apt-get install -yq --no-install-recommends ncdu \
       && rm -rf /var/lib/apt/lists/*
   
   COPY start-tb-vc-executor.sh ${pkg.name}.deb /tmp/
   
   RUN mkdir -p /home/thingsboard/.config/jgit \
       && chown -R ${pkg.user}:${pkg.user} /home/thingsboard \
       && chmod a+x /tmp/*.sh \
       && mv /tmp/start-tb-vc-executor.sh /usr/bin && \
       (yes | dpkg -i /tmp/${pkg.name}.deb) && \
       rm /tmp/${pkg.name}.deb && \
       (systemctl --no-reload disable --now ${pkg.name}.service > /dev/null 2>&1 || :) && \
       chmod 555 ${pkg.installFolder}/bin/${pkg.name}.jar
   
   USER ${pkg.user}
   CMD ["start-tb-vc-executor.sh"]
   ```

3. **关键特点**:
   - ✅ 使用 Java 基础镜像
   - ✅ 使用 DEB 包安装
   - ✅ 额外安装 `ncdu` 工具
   - ✅ 创建 jgit 配置目录

**构建命令**:
```bash
mvn clean install -DskipTests -Ddockerfile.skip=false --projects msa/vc-executor-docker --also-make
```

---

### 3.6 镜像10: thingsboard/tb-edqs

**用途**: 事件驱动查询服务（Event-Driven Query Service）

**源码位置**:
- Java 源码: `edqs/`
- Docker 构建: `msa/edqs/`

**构建流程**:

1. **Maven 配置** (`msa/edqs/pom.xml`):
   ```xml
   <dependency>
       <groupId>org.thingsboard</groupId>
       <artifactId>edqs</artifactId>
       <classifier>deb</classifier>
       <type>deb</type>
   </dependency>
   ```

2. **Dockerfile** (`msa/edqs/docker/Dockerfile`):
   ```dockerfile
   FROM thingsboard/openjdk17:bookworm-slim
   
   COPY start-tb-edqs.sh ${pkg.name}.deb /tmp/
   
   RUN chmod a+x /tmp/*.sh \
       && mv /tmp/start-tb-edqs.sh /usr/bin && \
       (yes | dpkg -i /tmp/${pkg.name}.deb) && \
       rm /tmp/${pkg.name}.deb && \
       (systemctl --no-reload disable --now ${pkg.name}.service > /dev/null 2>&1 || :) && \
       chown -R ${pkg.user}:${pkg.user} /tmp && \
       chmod 555 ${pkg.installFolder}/bin/${pkg.name}.jar
   
   USER ${pkg.user}
   CMD ["start-tb-edqs.sh"]
   ```

3. **关键特点**:
   - ✅ 使用 Java 基础镜像
   - ✅ 使用 DEB 包安装
   - ✅ 与 tb-node 构建模式相同

**构建命令**:
```bash
mvn clean install -DskipTests -Ddockerfile.skip=false --projects msa/edqs --also-make
```

---

### 3.7 镜像11: thingsboard/haproxy-certbot

**说明**: 这个镜像不是 ThingsBoard 应用服务本身，而是 ThingsBoard 团队维护的 HAProxy 镜像。

**源码位置**: 不在当前仓库中（可能是独立的仓库）

**用途**: 负载均衡器 + SSL 证书管理（集成 Certbot）

**在 docker-compose.yml 中的使用**:
```yaml
haproxy:
  image: thingsboard/haproxy-certbot:2.2.33-alpine
```

**注意**: 这个镜像的构建配置不在当前源码仓库中。

## 4. 构建模式分类

### 4.1 模式1: DEB 包 + Java 基础镜像（7个镜像）

**适用镜像**:
- `tb-node` (core + rule-engine)
- `tb-mqtt-transport`
- `tb-http-transport`
- `tb-coap-transport`
- `tb-lwm2m-transport`
- `tb-snmp-transport`
- `tb-vc-executor`
- `tb-edqs`

**构建流程**:
```
Java 源码 → Maven 编译 → Gradle 打包 DEB → Dockerfile 安装 DEB → Docker 镜像
```

**特点**:
- ✅ 标准化安装流程
- ✅ 统一的文件结构
- ✅ 自动权限管理

### 4.2 模式2: 源代码 + Node.js 基础镜像（2个镜像）

**适用镜像**:
- `tb-web-ui`
- `tb-js-executor`

**构建流程**:
```
TypeScript/JavaScript 源码 → 复制到镜像 → 安装依赖 → Docker 镜像
```

**特点**:
- ✅ 直接复制源代码
- ✅ 在容器内安装依赖
- ✅ 不需要打包步骤

## 5. Maven 构建插件详解

### 5.1 dockerfile-maven-plugin

**作用**: 构建 Docker 镜像

**配置** (`msa/pom.xml`):
```xml
<plugin>
    <groupId>com.spotify</groupId>
    <artifactId>dockerfile-maven-plugin</artifactId>
    <version>1.4.13</version>
</plugin>
```

**执行阶段**: `pre-integration-test`

**功能**:
- `build`: 构建镜像
- `tag`: 打标签
- `push`: 推送镜像（需要 `push-docker-image` profile）

### 5.2 maven-dependency-plugin

**作用**: 复制依赖的 DEB 包或 JAR 包到构建目录

**示例** (`msa/tb-node/pom.xml`):
```xml
<execution>
    <id>copy-tb-deb</id>
    <phase>package</phase>
    <goals>
        <goal>copy</goal>
    </goals>
    <configuration>
        <artifactItems>
            <artifactItem>
                <groupId>org.thingsboard</groupId>
                <artifactId>application</artifactId>
                <classifier>deb</classifier>
                <type>deb</type>
                <destFileName>${pkg.name}.deb</destFileName>
                <outputDirectory>${project.build.directory}</outputDirectory>
            </artifactItem>
        </artifactItems>
    </configuration>
</execution>
```

### 5.3 maven-resources-plugin

**作用**: 复制 Dockerfile 和启动脚本到构建目录

**示例**:
```xml
<execution>
    <id>copy-docker-config</id>
    <phase>process-resources</phase>
    <goals>
        <goal>copy-resources</goal>
    </goals>
    <configuration>
        <outputDirectory>${project.build.directory}</outputDirectory>
        <resources>
            <resource>
                <directory>docker</directory>
                <filtering>true</filtering>  <!-- 支持变量替换 -->
            </resource>
        </resources>
    </configuration>
</execution>
```

### 5.4 frontend-maven-plugin

**作用**: 管理 Node.js 和 Yarn（用于 web-ui 和 js-executor）

**功能**:
- 安装 Node.js 和 Yarn
- 执行 `yarn install`
- 执行 `yarn run pkg`

## 6. 构建目录结构

### 6.1 构建后的目录结构

每个 `msa/*/target/` 目录包含：

```
msa/tb-node/target/
├── Dockerfile              # 从 docker/ 目录复制
├── start-tb-node.sh       # 从 docker/ 目录复制
├── logback.xml            # 从 docker/ 目录复制
└── thingsboard.deb        # 从 application/target/ 复制
```

### 6.2 Docker 构建上下文

`dockerfile-maven-plugin` 使用 `target/` 目录作为构建上下文：

```xml
<contextDirectory>${project.build.directory}</contextDirectory>
```

## 7. 完整构建命令

### 7.1 构建所有镜像

```bash
# 构建所有 ThingsBoard 镜像
mvn clean install -DskipTests -Ddockerfile.skip=false

# 或使用 build.sh（需要修改）
./build.sh
```

### 7.2 构建特定镜像

```bash
# 构建单个镜像
mvn clean install -DskipTests -Ddockerfile.skip=false \
  --projects msa/tb-node --also-make

# 构建多个镜像
mvn clean install -DskipTests -Ddockerfile.skip=false \
  --projects msa/tb-node,msa/web-ui,msa/js-executor --also-make
```

### 7.3 构建并推送镜像

```bash
# 构建并推送到 Docker Hub
mvn clean install -DskipTests \
  -Ddockerfile.skip=false \
  -Dpush-docker-image=true
```

**注意**: 推送需要：
1. Docker Hub 账号
2. 登录: `docker login`
3. 推送权限

## 8. 构建依赖关系

### 8.1 依赖顺序

```
1. common/* (公共模块)
   ↓
2. dao (数据访问层)
   ↓
3. application (主应用) → 生成 thingsboard.deb
   ↓
4. transport/* (传输模块) → 生成 tb-*-transport.deb
   ↓
5. ui-ngx (前端) → 生成 ui-ngx.jar
   ↓
6. msa/tb-node → 使用 thingsboard.deb
7. msa/transport/* → 使用 tb-*-transport.deb
8. msa/web-ui → 使用 ui-ngx.jar
9. msa/js-executor → 直接复制源码
10. msa/vc-executor-docker → 使用 vc-executor.deb
11. msa/edqs → 使用 edqs.deb
```

### 8.2 使用 --also-make 自动构建依赖

`--also-make` 参数会自动构建依赖的模块：

```bash
# 只需要指定 msa/tb-node，会自动构建 application 模块
mvn clean install -DskipTests -Ddockerfile.skip=false \
  --projects msa/tb-node --also-make
```

## 9. 镜像标签和版本

### 9.1 标签生成

构建时会生成两个标签：

1. **版本标签**: `thingsboard/tb-node:4.2.1`
2. **Latest 标签**: `thingsboard/tb-node:latest`（仅推送时）

### 9.2 版本来源

版本号来自根 `pom.xml`:
```xml
<version>4.2.1</version>
```

## 10. 基础镜像说明

### 10.1 thingsboard/openjdk17:bookworm-slim

**用途**: Java 服务的基础镜像

**来源**: ThingsBoard 团队维护的基础镜像

**特点**:
- 基于 Debian Bookworm Slim
- 包含 OpenJDK 17
- 轻量级（slim 版本）

### 10.2 thingsboard/node:22.18.0-bookworm-slim

**用途**: Node.js 服务的基础镜像

**特点**:
- 基于 Debian Bookworm Slim
- 包含 Node.js 22.18.0
- 包含 Yarn

## 11. 构建产物位置

### 11.1 DEB 包位置

- `application/target/thingsboard-4.2.1-boot.deb`
- `transport/mqtt/target/tb-mqtt-transport-4.2.1.deb`
- `transport/http/target/tb-http-transport-4.2.1.deb`
- `transport/coap/target/tb-coap-transport-4.2.1.deb`
- `transport/lwm2m/target/tb-lwm2m-transport-4.2.1.deb`
- `transport/snmp/target/tb-snmp-transport-4.2.1.deb`

### 11.2 JAR 包位置

- `ui-ngx/target/ui-ngx-4.2.1.jar`（包含前端静态资源）

### 11.3 Docker 镜像

构建完成后，镜像保存在本地 Docker：
```bash
docker images | grep thingsboard
```

## 12. 关键文件位置总结

| 镜像 | 源码位置 | Dockerfile | pom.xml | DEB/JAR 来源 |
|-----|---------|-----------|---------|------------|
| **tb-node** | `application/` | `msa/tb-node/docker/Dockerfile` | `msa/tb-node/pom.xml` | `application/target/*.deb` |
| **tb-mqtt-transport** | `transport/mqtt/` | `msa/transport/mqtt/docker/Dockerfile` | `msa/transport/mqtt/pom.xml` | `transport/mqtt/target/*.deb` |
| **tb-http-transport** | `transport/http/` | `msa/transport/http/docker/Dockerfile` | `msa/transport/http/pom.xml` | `transport/http/target/*.deb` |
| **tb-coap-transport** | `transport/coap/` | `msa/transport/coap/docker/Dockerfile` | `msa/transport/coap/pom.xml` | `transport/coap/target/*.deb` |
| **tb-lwm2m-transport** | `transport/lwm2m/` | `msa/transport/lwm2m/docker/Dockerfile` | `msa/transport/lwm2m/pom.xml` | `transport/lwm2m/target/*.deb` |
| **tb-snmp-transport** | `transport/snmp/` | `msa/transport/snmp/docker/Dockerfile` | `msa/transport/snmp/pom.xml` | `transport/snmp/target/*.deb` |
| **tb-web-ui** | `ui-ngx/` | `msa/web-ui/docker/Dockerfile` | `msa/web-ui/pom.xml` | `ui-ngx/target/*.jar` |
| **tb-js-executor** | `msa/js-executor/src/` | `msa/js-executor/docker/Dockerfile` | `msa/js-executor/pom.xml` | 无（直接复制源码） |
| **tb-vc-executor** | `msa/vc-executor/` | `msa/vc-executor-docker/docker/Dockerfile` | `msa/vc-executor-docker/pom.xml` | `msa/vc-executor/target/*.deb` |
| **tb-edqs** | `edqs/` | `msa/edqs/docker/Dockerfile` | `msa/edqs/pom.xml` | `edqs/target/*.deb` |

## 13. 总结

### 13.1 构建方式统计

- **DEB 包模式**: 8个镜像（tb-node、5个传输服务、vc-executor、edqs）
- **源码复制模式**: 2个镜像（web-ui、js-executor）
- **独立维护**: 1个镜像（haproxy-certbot，不在当前仓库）

### 13.2 构建工具

- **Maven**: 统一构建工具
- **dockerfile-maven-plugin**: Docker 镜像构建
- **Gradle**: DEB 包构建（通过 Maven 调用）

### 13.3 关键发现

1. ✅ **统一构建**: 所有镜像都通过 Maven 统一构建
2. ✅ **标准化**: Java 服务使用 DEB 包，Node.js 服务使用源码
3. ✅ **模块化**: 每个镜像都有独立的构建配置
4. ✅ **可扩展**: 支持添加新的镜像和服务

通过这个详细分析，可以清楚地了解 ThingsBoard 11 个自身镜像的完整打包流程和构建方式。