# ThingsBoard Docker 目录全面分析

## 1. 目录概述

`docker/` 目录是 ThingsBoard 微服务架构的 **Docker Compose 部署配置目录**，提供了完整的容器化部署方案。该目录包含：

- Docker Compose 配置文件（模块化设计）
- 部署管理脚本
- 环境变量配置文件
- 服务配置文件
- 监控配置
- 负载均衡配置

## 2. 目录结构

```
docker/
├── 脚本文件/
│   ├── docker-install-tb.sh          # 安装脚本（数据库初始化）
│   ├── docker-start-services.sh      # 启动所有服务
│   ├── docker-stop-services.sh       # 停止所有服务
│   ├── docker-remove-services.sh     # 删除服务容器
│   ├── docker-update-service.sh       # 更新服务
│   ├── docker-upgrade-tb.sh          # 数据库升级
│   ├── docker-create-log-folders.sh   # 创建日志目录
│   ├── docker-check-log-folders.sh   # 检查日志目录
│   └── compose-utils.sh              # 工具函数库
│
├── Docker Compose 配置文件/
│   ├── docker-compose.yml             # 主配置文件（定义所有服务）
│   ├── docker-compose.postgres.yml    # PostgreSQL 数据库配置
│   ├── docker-compose.hybrid.yml      # 混合模式（PostgreSQL + Cassandra）
│   ├── docker-compose.kafka.yml       # Kafka 消息队列配置
│   ├── docker-compose.confluent.yml   # Confluent Kafka 配置
│   ├── docker-compose.valkey.yml      # Valkey 单节点缓存配置
│   ├── docker-compose.valkey-cluster.yml  # Valkey 集群配置
│   ├── docker-compose.valkey-sentinel.yml # Valkey 哨兵模式配置
│   ├── docker-compose.edqs.yml       # 事件驱动查询服务配置
│   ├── docker-compose.prometheus-grafana.yml  # 监控服务配置
│   └── docker-compose.*.volumes.yml   # 数据卷配置
│
├── 环境变量配置文件/
│   ├── tb-node.env                    # 核心服务通用配置
│   ├── tb-node.postgres.env           # PostgreSQL 数据库配置
│   ├── tb-node.hybrid.env             # 混合模式数据库配置
│   ├── tb-mqtt-transport.env          # MQTT 传输服务配置
│   ├── tb-http-transport.env          # HTTP 传输服务配置
│   ├── tb-coap-transport.env          # CoAP 传输服务配置
│   ├── tb-lwm2m-transport.env         # LWM2M 传输服务配置
│   ├── tb-snmp-transport.env          # SNMP 传输服务配置
│   ├── tb-web-ui.env                  # Web UI 配置
│   ├── tb-js-executor.env             # JavaScript 执行器配置
│   ├── tb-vc-executor.env             # 版本控制执行器配置
│   ├── tb-edqs.env                    # EDQS 服务配置
│   ├── queue-kafka.env                # Kafka 队列配置
│   ├── queue-confluent.env            # Confluent 队列配置
│   ├── cache-valkey.env               # Valkey 单节点配置
│   ├── cache-valkey-cluster.env        # Valkey 集群配置
│   ├── cache-valkey-sentinel.env       # Valkey 哨兵配置
│   └── kafka.env                      # Kafka 服务配置
│
├── 配置目录/
│   ├── tb-node/                       # 核心服务配置
│   │   ├── conf/                      # 配置文件
│   │   └── log/                       # 日志目录
│   ├── tb-transports/                 # 传输服务配置
│   │   ├── mqtt/conf/                 # MQTT 配置
│   │   ├── http/conf/                 # HTTP 配置
│   │   ├── coap/conf/                 # CoAP 配置
│   │   ├── lwm2m/conf/                # LWM2M 配置
│   │   └── snmp/conf/                 # SNMP 配置
│   ├── tb-vc-executor/                # 版本控制执行器配置
│   ├── tb-edqs/                       # EDQS 服务配置
│   ├── haproxy/                       # HAProxy 负载均衡配置
│   │   └── config/
│   │       ├── haproxy.cfg            # HAProxy 主配置
│   │       ├── blocklist.txt          # 黑名单
│   │       └── trustlist.txt          # 白名单
│   └── monitoring/                    # 监控配置
│       ├── prometheus/
│       │   └── prometheus.yml        # Prometheus 配置
│       └── grafana/
│           ├── config.monitoring      # Grafana 配置
│           └── provisioning/          # 仪表板和数据源配置
│
└── README.md                          # 使用说明文档
```

## 3. 核心脚本分析

### 3.1 docker-install-tb.sh

**作用**: 执行 ThingsBoard 的初始安装，包括数据库 schema 初始化。

**关键功能**:
- 启动数据库服务（PostgreSQL/Cassandra）
- 运行 `tb-core1` 容器执行数据库初始化
- 可选加载演示数据（`--loadDemo` 参数）

**执行流程**:
```bash
1. 读取 .env 文件配置
2. 根据配置组合 Docker Compose 文件
3. 启动数据库和缓存服务（depends_on）
4. 运行 tb-core1 容器，设置 INSTALL_TB=true
5. 执行数据库 schema 创建和初始化
6. 可选加载演示数据
```

**使用示例**:
```bash
# 基本安装
./docker-install-tb.sh

# 安装并加载演示数据
./docker-install-tb.sh --loadDemo
```

### 3.2 docker-start-services.sh

**作用**: 启动所有 ThingsBoard 微服务。

**关键功能**:
- 组合所有 Docker Compose 配置文件
- 启动所有服务（`docker compose up -d`）
- 支持 Docker Compose V1 和 V2

**执行流程**:
```bash
1. 读取 .env 配置
2. 根据配置选择对应的 Compose 文件
3. 组合命令：docker compose -f docker-compose.yml -f ... up -d
4. 启动所有服务
```

### 3.3 docker-stop-services.sh

**作用**: 停止所有运行中的服务。

**执行命令**: `docker compose stop`

### 3.4 docker-remove-services.sh

**作用**: 停止并删除所有服务容器和数据卷。

**执行命令**: `docker compose down -v`

**注意**: 这会删除所有数据，谨慎使用！

### 3.5 docker-update-service.sh

**作用**: 更新特定服务或所有服务。

**功能**:
- 拉取最新镜像（`docker compose pull`）
- 重新构建并启动服务（`docker compose up -d --no-deps --build`）

**使用示例**:
```bash
# 更新所有服务
./docker-update-service.sh

# 更新特定服务
./docker-update-service.sh tb-core1 tb-mqtt-transport1
```

### 3.6 docker-upgrade-tb.sh

**作用**: 执行 ThingsBoard 数据库升级。

**关键参数**:
- `--fromVersion=[VERSION]`: 指定从哪个版本升级

**使用示例**:
```bash
./docker-upgrade-tb.sh --fromVersion=3.6.0
```

### 3.7 compose-utils.sh

**作用**: 工具函数库，提供配置组合逻辑。

**核心函数**:

1. **additionalComposeArgs()**: 根据 `DATABASE` 环境变量选择数据库配置
   - `postgres` → `docker-compose.postgres.yml`
   - `hybrid` → `docker-compose.hybrid.yml`

2. **additionalComposeQueueArgs()**: 根据 `TB_QUEUE_TYPE` 选择队列配置
   - `kafka` → `docker-compose.kafka.yml`
   - `confluent` → `docker-compose.confluent.yml`

3. **additionalComposeCacheArgs()**: 根据 `CACHE` 选择缓存配置
   - `valkey` → `docker-compose.valkey.yml`
   - `valkey-cluster` → `docker-compose.valkey-cluster.yml`
   - `valkey-sentinel` → `docker-compose.valkey-sentinel.yml`

4. **additionalComposeMonitoringArgs()**: 根据 `MONITORING_ENABLED` 启用监控
   - `true` → `docker-compose.prometheus-grafana.yml`

5. **additionalComposeEdqsArgs()**: 根据 `EDQS_ENABLED` 启用 EDQS
   - `true` → `docker-compose.edqs.yml`

6. **composeVersion()**: 检测 Docker Compose 版本（V1 或 V2）

7. **permissionList()**: 返回需要创建的目录和权限列表

8. **checkFolders()**: 检查或创建日志目录并设置权限

## 4. Docker Compose 配置文件分析

### 4.1 主配置文件：docker-compose.yml

**作用**: 定义所有 ThingsBoard 微服务的配置。

**包含的服务**:

#### 基础设施服务
- **zookeeper**: 服务发现和协调
  - 镜像: `zookeeper:3.8.1`
  - 端口: `2181`

#### 核心服务
- **tb-core1, tb-core2**: 核心服务（2个实例，高可用）
  - 镜像: `thingsboard/tb-node:{version}`
  - 服务类型: `tb-core`
  - 端口: `8080` (HTTP API), `7070` (Edge RPC)
  - 日志: 最大 200MB，保留 30 个文件

- **tb-rule-engine1, tb-rule-engine2**: 规则引擎服务（2个实例）
  - 镜像: `thingsboard/tb-node:{version}`
  - 服务类型: `tb-rule-engine`
  - 端口: `8080`

#### 传输服务
- **tb-mqtt-transport1, tb-mqtt-transport2**: MQTT 传输（2个实例）
  - 镜像: `thingsboard/tb-mqtt-transport:{version}`
  - 端口: `1883`

- **tb-http-transport1, tb-http-transport2**: HTTP 传输（2个实例）
  - 镜像: `thingsboard/tb-http-transport:{version}`
  - 端口: `8081`

- **tb-coap-transport**: CoAP 传输（1个实例）
  - 镜像: `thingsboard/tb-coap-transport:{version}`
  - 端口: `5683/udp`

- **tb-lwm2m-transport**: LWM2M 传输（1个实例）
  - 镜像: `thingsboard/tb-lwm2m-transport:{version}`
  - 端口: `5685/udp`, `5686/udp`

- **tb-snmp-transport**: SNMP 传输（1个实例）
  - 镜像: `thingsboard/tb-snmp-transport:{version}`
  - 端口: `1620/udp`

#### 前端服务
- **tb-web-ui1, tb-web-ui2**: Web UI 服务（2个实例）
  - 镜像: `thingsboard/tb-web-ui:{version}`
  - 端口: `8080`

#### 辅助服务
- **tb-js-executor**: JavaScript 执行器
  - 镜像: `thingsboard/tb-js-executor:{version}`
  - 副本数: 10（高并发执行）

- **tb-vc-executor1, tb-vc-executor2**: 版本控制执行器（2个实例）
  - 镜像: `thingsboard/tb-vc-executor:{version}`
  - 端口: `8081`

#### 负载均衡
- **haproxy**: 负载均衡器
  - 镜像: `thingsboard/haproxy-certbot:2.2.33-alpine`
  - 端口: `80` (HTTP), `443` (HTTPS), `1883` (MQTT), `7070` (Edge RPC), `9999` (统计)

### 4.2 数据库配置

#### docker-compose.postgres.yml

**作用**: PostgreSQL 模式配置，所有数据存储在 PostgreSQL。

**包含服务**:
- **postgres**: PostgreSQL 16
  - 数据库: `thingsboard`
  - 数据卷: `./tb-node/postgres`

**适用场景**: 中小型部署，设备数量 < 10,000

#### docker-compose.hybrid.yml

**作用**: 混合模式配置，PostgreSQL 存储实体数据，Cassandra 存储时序数据。

**包含服务**:
- **postgres**: PostgreSQL 16（实体数据）
- **cassandra**: Cassandra 5.0（时序数据）
  - 端口: `9042`
  - 数据卷: `./tb-node/cassandra`

**适用场景**: 大型部署，高写入量时序数据

### 4.3 消息队列配置

#### docker-compose.kafka.yml

**作用**: Kafka 消息队列配置。

**包含服务**:
- **kafka**: Kafka 4.0（使用 KRaft 模式，不需要 ZooKeeper）
  - 镜像: `bitnamilegacy/kafka:4.0`
  - 端口: `9092`

**特点**: 所有 ThingsBoard 服务都依赖 Kafka 进行消息传递

#### docker-compose.confluent.yml

**作用**: Confluent Kafka 配置（生产环境推荐）。

**特点**: 提供企业级 Kafka 功能

### 4.4 缓存配置

#### docker-compose.valkey.yml

**作用**: Valkey 单节点缓存配置。

**包含服务**:
- **valkey**: Valkey 8.0（单节点）
  - 镜像: `bitnamilegacy/valkey:8.0`
  - 端口: `6379`
  - 数据卷: `./tb-node/valkey-data`

**适用场景**: 开发测试环境

#### docker-compose.valkey-cluster.yml

**作用**: Valkey 集群配置（高可用）。

**包含服务**:
- **valkey-node-0 到 valkey-node-5**: 6个节点（3主3从）
  - 镜像: `bitnamilegacy/valkey-cluster:8.0`
  - 副本因子: 1

**适用场景**: 生产环境，高可用要求

#### docker-compose.valkey-sentinel.yml

**作用**: Valkey 哨兵模式配置（自动故障转移）。

**包含服务**:
- **valkey-primary**: 主节点
- **valkey-replica**: 从节点
- **valkey-sentinel**: 哨兵节点

**适用场景**: 生产环境，需要自动故障转移

### 4.5 其他配置

#### docker-compose.edqs.yml

**作用**: 事件驱动查询服务配置。

**包含服务**:
- **tb-edqs1, tb-edqs2**: EDQS 服务（2个实例）

**作用**: 提供高效的时序数据查询服务

#### docker-compose.prometheus-grafana.yml

**作用**: 监控服务配置。

**包含服务**:
- **prometheus**: Prometheus v3.1.0
  - 端口: `9090`
  - 配置: `./monitoring/prometheus/prometheus.yml`

- **grafana**: Grafana
  - 端口: `3000`
  - 默认登录: `admin` / `foobar`

**启用方式**: 设置 `MONITORING_ENABLED=true` 在 `.env` 文件中

## 5. 环境变量配置文件分析

### 5.1 核心服务配置

#### tb-node.env

**作用**: 核心服务和规则引擎服务的通用配置。

**关键配置**:
```bash
ZOOKEEPER_ENABLED=true           # 启用 ZooKeeper 服务发现
ZOOKEEPER_URL=zookeeper:2181    # ZooKeeper 地址
JS_EVALUATOR=remote              # 使用远程 JS 执行器
TRANSPORT_TYPE=remote            # 使用远程传输服务
METRICS_ENABLED=true             # 启用监控指标
METRICS_ENDPOINTS_EXPOSE=prometheus  # 暴露 Prometheus 指标
```

#### tb-node.postgres.env

**作用**: PostgreSQL 数据库配置。

**关键配置**:
```bash
DATABASE_TS_TYPE=sql                                    # SQL 模式
SPRING_DRIVER_CLASS_NAME=org.postgresql.Driver         # PostgreSQL 驱动
SPRING_DATASOURCE_URL=jdbc:postgresql://postgres:5432/thingsboard
SPRING_DATASOURCE_USERNAME=postgres
SPRING_DATASOURCE_PASSWORD=postgres
```

#### tb-node.hybrid.env

**作用**: 混合模式数据库配置。

**关键配置**:
```bash
DATABASE_TS_TYPE=cassandra                    # 时序数据使用 Cassandra
CASSANDRA_URL=cassandra:9042                  # Cassandra 地址
SPRING_DATASOURCE_URL=jdbc:postgresql://postgres:5432/thingsboard  # 实体数据使用 PostgreSQL
```

### 5.2 传输服务配置

#### tb-mqtt-transport.env

**关键配置**:
```bash
ZOOKEEPER_ENABLED=true
ZOOKEEPER_URL=zookeeper:2181
MQTT_BIND_ADDRESS=0.0.0.0
MQTT_BIND_PORT=1883
MQTT_TIMEOUT=10000
METRICS_ENABLED=true
```

#### tb-http-transport.env

**关键配置**:
```bash
HTTP_BIND_PORT=8081
WEB_APPLICATION_ENABLE=true
```

### 5.3 队列配置

#### queue-kafka.env

**关键配置**:
```bash
TB_QUEUE_TYPE=kafka
TB_KAFKA_SERVERS=kafka:9092
```

### 5.4 缓存配置

#### cache-valkey.env

**关键配置**:
```bash
CACHE_TYPE=redis           # 注意：配置名仍然是 redis（兼容性）
REDIS_HOST=valkey         # Valkey 服务地址
```

#### cache-valkey-cluster.env

**关键配置**:
```bash
CACHE_TYPE=redis-cluster
REDIS_CLUSTER_NODES=valkey-node-0:6379,valkey-node-1:6379,...
```

## 6. 配置组合机制

### 6.1 工作原理

ThingsBoard 使用 **模块化 Docker Compose 配置**，通过 `.env` 文件选择不同的配置组合：

1. **读取 `.env` 文件**，获取配置选择：
   ```bash
   DATABASE=postgres        # 或 hybrid
   CACHE=valkey            # 或 valkey-cluster, valkey-sentinel
   TB_QUEUE_TYPE=kafka     # 或 confluent
   MONITORING_ENABLED=false  # 或 true
   EDQS_ENABLED=false      # 或 true
   ```

2. **脚本组合 Compose 文件**：
   ```bash
   docker compose \
     -f docker-compose.yml \                    # 主配置
     -f docker-compose.postgres.yml \           # 数据库配置
     -f docker-compose.kafka.yml \              # 队列配置
     -f docker-compose.valkey.yml \             # 缓存配置
     -f docker-compose.prometheus-grafana.yml \ # 监控（可选）
     up -d
   ```

3. **服务继承配置**：
   - 主配置文件定义所有服务
   - 附加配置文件覆盖特定服务的配置（如数据库连接、缓存配置）

### 6.2 配置覆盖示例

**主配置** (`docker-compose.yml`):
```yaml
tb-core1:
  env_file:
    - tb-node.env
```

**数据库配置** (`docker-compose.postgres.yml`):
```yaml
tb-core1:
  env_file:
    - tb-node.postgres.env  # 追加数据库配置
```

**最终效果**: `tb-core1` 会加载 `tb-node.env` 和 `tb-node.postgres.env` 两个文件

## 7. 部署架构

### 7.1 完整架构图

```
┌─────────────────────────────────────────────────────────────┐
│                    HAProxy (负载均衡器)                       │
│  Ports: 80 (HTTP), 443 (HTTPS), 1883 (MQTT), 7070 (RPC)    │
└────────────────────┬────────────────────────────────────────┘
                     │
     ┌───────────────┼───────────────┐
     │               │               │
     ▼               ▼               ▼
┌─────────┐   ┌─────────┐   ┌─────────┐
│Web UI 1 │   │Web UI 2 │   │MQTT Tx1 │   │MQTT Tx2 │
└────┬────┘   └────┬────┘   └────┬────┘   └────┬────┘
     │             │             │             │
     └─────────────┼─────────────┼─────────────┘
                   │             │
                   ▼             ▼
         ┌─────────────────────────┐
         │      Kafka Queue         │
         │    (消息队列)             │
         └───────────┬───────────────┘
                     │
         ┌───────────┼───────────┐
         │                       │
         ▼                       ▼
  ┌──────────┐          ┌──────────────┐
  │tb-core1  │          │tb-core2     │
  │tb-core2  │          │(核心服务)    │
  └────┬─────┘          └──────┬───────┘
       │                       │
       └───────────┬───────────┘
                   │
         ┌─────────┼─────────┐
         │                   │
         ▼                   ▼
  ┌──────────────┐   ┌──────────────┐
  │PostgreSQL    │   │  Cassandra   │
  │(实体数据)     │   │  (时序数据)   │
  └──────────────┘   └──────────────┘

基础服务:
  - ZooKeeper (服务发现)
  - Valkey (缓存)
  - JS Executor (JavaScript 执行)
```

### 7.2 服务依赖关系

```
启动顺序（depends_on）:
1. ZooKeeper
2. PostgreSQL / Cassandra
3. Kafka
4. Valkey
5. tb-js-executor
6. tb-core1, tb-core2
7. tb-rule-engine1, tb-rule-engine2
8. 传输服务（tb-mqtt-transport, ...）
9. tb-web-ui
10. HAProxy
```

## 8. 使用流程

### 8.1 首次部署

```bash
# 1. 配置 .env 文件
cat > .env << EOF
DATABASE=postgres          # 或 hybrid
CACHE=valkey              # 或 valkey-cluster
TB_QUEUE_TYPE=kafka       # 或 confluent
MONITORING_ENABLED=false  # 或 true
EDQS_ENABLED=false        # 或 true
EOF

# 2. 创建日志目录
./docker-create-log-folders.sh

# 3. 安装（初始化数据库）
./docker-install-tb.sh --loadDemo

# 4. 启动所有服务
./docker-start-services.sh

# 5. 访问 Web UI
# http://localhost
# 默认账号: sysadmin@thingsboard.org / sysadmin
```

### 8.2 日常操作

```bash
# 启动服务
./docker-start-services.sh

# 停止服务
./docker-stop-services.sh

# 查看日志
docker-compose logs -f tb-core1

# 更新服务
./docker-update-service.sh tb-core1

# 查看服务状态
docker-compose ps
```

### 8.3 升级流程

```bash
# 1. 停止服务
./docker-stop-services.sh

# 2. 执行升级
./docker-upgrade-tb.sh --fromVersion=3.6.0

# 3. 启动服务
./docker-start-services.sh
```

## 9. 数据持久化

### 9.1 数据卷映射

所有数据都映射到 `docker/` 目录下：

```
docker/
├── tb-node/
│   ├── postgres/        # PostgreSQL 数据
│   ├── cassandra/        # Cassandra 数据（混合模式）
│   ├── valkey-data/      # Valkey 数据（单节点）
│   ├── valkey-cluster-data-0/  # Valkey 集群数据
│   └── log/             # 应用日志
├── tb-transports/
│   └── */log/           # 传输服务日志
└── haproxy/
    ├── letsencrypt/     # SSL 证书
    └── certs.d/         # 自定义证书
```

### 9.2 备份建议

```bash
# 备份 PostgreSQL 数据
docker exec postgres pg_dump -U postgres thingsboard > backup.sql

# 备份 Cassandra 数据
# 使用 Cassandra 的备份工具

# 备份配置
tar -czf tb-config-backup.tar.gz docker/tb-node/conf docker/tb-transports/*/conf
```

## 10. 监控和日志

### 10.1 日志配置

所有服务都配置了日志轮转：
- 最大文件大小: 200MB
- 保留文件数: 30
- 总日志大小: 6GB (200MB × 30)

### 10.2 Prometheus 监控

启用监控后：
- Prometheus: http://localhost:9090
- Grafana: http://localhost:3000

预置仪表板：
- Core Service Metrics
- Rule Engine Metrics
- Transport Metrics
- Database Metrics

## 11. 高可用配置

### 11.1 服务冗余

- **tb-core**: 2个实例
- **tb-rule-engine**: 2个实例
- **tb-mqtt-transport**: 2个实例
- **tb-http-transport**: 2个实例
- **tb-web-ui**: 2个实例
- **tb-js-executor**: 10个副本（高并发）

### 11.2 负载均衡

HAProxy 在所有服务实例间进行负载均衡：
- HTTP/HTTPS 流量 → Web UI 和 Core API
- MQTT 连接 → MQTT Transport
- Edge RPC → Core Service

### 11.3 数据库高可用

- **PostgreSQL**: 可以配置主从复制（需要额外配置）
- **Cassandra**: 集群模式（多节点）
- **Valkey**: 集群或哨兵模式

## 12. 安全配置

### 12.1 网络隔离

- 所有服务在同一个 Docker 网络中
- 数据库端口不映射到宿主机（仅内部访问）
- 通过 HAProxy 统一对外暴露端口

### 12.2 SSL/TLS

HAProxy 支持 SSL/TLS：
- Let's Encrypt 自动证书（`./haproxy/letsencrypt/`）
- 自定义证书（`./haproxy/certs.d/`）

### 12.3 密码配置

**注意**: 默认配置使用明文密码，生产环境需要修改：
- PostgreSQL 密码: `tb-node.postgres.env`
- Valkey 密码: `docker-compose.valkey-cluster.yml`

## 13. 常见配置组合

### 13.1 开发测试环境

```bash
DATABASE=postgres
CACHE=valkey
TB_QUEUE_TYPE=kafka
MONITORING_ENABLED=false
EDQS_ENABLED=false
```

**特点**: 简单配置，资源占用少

### 13.2 生产环境（小型）

```bash
DATABASE=postgres
CACHE=valkey-sentinel
TB_QUEUE_TYPE=kafka
MONITORING_ENABLED=true
EDQS_ENABLED=false
```

**特点**: 高可用缓存，启用监控

### 13.3 生产环境（大型）

```bash
DATABASE=hybrid
CACHE=valkey-cluster
TB_QUEUE_TYPE=confluent
MONITORING_ENABLED=true
EDQS_ENABLED=true
```

**特点**: 混合数据库，集群缓存，企业级队列，启用监控和 EDQS

## 14. 最佳实践

### 14.1 配置管理

1. **使用环境变量**: 敏感信息通过环境变量传递
2. **版本控制**: 配置文件纳入版本控制
3. **分离配置**: 不同环境使用不同的 `.env` 文件

### 14.2 资源规划

- **内存**: 至少 8GB（推荐 16GB+）
- **CPU**: 至少 4 核（推荐 8 核+）
- **磁盘**: 至少 50GB（根据数据量调整）

### 14.3 监控建议

1. **启用监控**: 生产环境必须启用 Prometheus + Grafana
2. **设置告警**: 配置 Grafana 告警规则
3. **日志收集**: 考虑使用 ELK 或 Loki 收集日志

### 14.4 备份策略

1. **数据库备份**: 定期备份 PostgreSQL 和 Cassandra
2. **配置备份**: 备份所有配置文件
3. **测试恢复**: 定期测试备份恢复流程

## 15. 故障排查

### 15.1 常见问题

**问题1: 服务启动失败**

```bash
# 检查日志
docker-compose logs tb-core1

# 检查依赖服务
docker-compose ps

# 检查网络
docker network ls
```

**问题2: 数据库连接失败**

```bash
# 检查数据库是否运行
docker-compose ps postgres

# 检查数据库日志
docker-compose logs postgres

# 测试连接
docker exec -it postgres psql -U postgres -d thingsboard
```

**问题3: 端口冲突**

```bash
# 检查端口占用
netstat -tulpn | grep 8080

# 修改端口映射（在 docker-compose.yml 中）
ports:
  - "8081:8080"  # 将宿主机端口改为 8081
```

### 15.2 调试技巧

```bash
# 进入容器
docker exec -it tb-core1 bash

# 查看环境变量
docker exec tb-core1 env

# 查看配置文件
docker exec tb-core1 cat /config/thingsboard.yml

# 实时查看日志
docker-compose logs -f --tail=100 tb-core1
```

## 16. 总结

### 16.1 Docker 目录的核心价值

1. **模块化设计**: 通过组合不同的 Compose 文件，支持灵活的配置
2. **一键部署**: 脚本封装了复杂的部署流程
3. **生产就绪**: 包含高可用、监控、负载均衡等生产环境必需组件
4. **易于维护**: 清晰的目录结构和配置分离

### 16.2 关键特点

- ✅ **微服务架构**: 服务拆分，独立部署和扩展
- ✅ **高可用**: 关键服务多实例部署
- ✅ **灵活配置**: 支持多种数据库、队列、缓存选择
- ✅ **监控集成**: 内置 Prometheus + Grafana
- ✅ **负载均衡**: HAProxy 统一入口
- ✅ **容器化**: 完全基于 Docker，易于部署和管理

### 16.3 适用场景

- ✅ **生产环境**: 微服务模式，高可用部署
- ✅ **开发测试**: 快速搭建完整环境
- ✅ **演示环境**: 支持加载演示数据
- ✅ **CI/CD**: 可以集成到持续集成流程

通过这个 Docker 目录，ThingsBoard 提供了一个 **企业级的容器化部署方案**，大大简化了部署和运维工作。