技术交流

学习资料

立即试用 商务报价
社区版
社区版 专业版 云服务 Edge Edge PE 网关 授权服务 Trendz分析 Mobile 应用程序 Mobile PE应用程序
安装 > 本地环境 > Windows
入门 文档 指南
架构 API 常见问题

本页目录

Windows安装

ThingsBoard云服务

建议你的物联网应用程序使用ThingsBoard云服务完全托管,可扩展和容错的平台。
ThingsBoard云服务适用于想要使用ThingsBoard但又不想自己托管平台实例的每个人。

请使用Linux安装选项因为它是运行ThingsBoard的最稳定的平台,Windows安装将在未来被弃用可以在安装指南页面上找到Linux安装指南

先决条件

本指南介绍了如何在Windows 10/8.1/8/7 32位/64位上安装ThingsBoard。
硬件要求取决于选择的数据库和连接到系统的设备数量。
需要一台1G内存的服务器运行ThingsBoard和PostgreSQL。
需要一台8G内存的服务器运行ThingsBoard和Cassandra。

步骤1. 安装Java 11(OpenJDK)

ThingsBoard基于Java11运行按照以下说明安装OpenJDK 11。

  • 访问Open JDK页面下载最新的OpenJDK 11(LTS) MSI软件包
  • 运行下载的MSI软件包勾选”Add to PATH“和”Set JAVA_HOME variable“选项进行安装
  • 访问PostgreSQL JDBC页面下载驱动程序
  • 复制C:\Program Files\AdoptOpenJDK\jdk-11.0.10.9-hotspot\jre\lib\ext路径添加CLASSPATH变量值为“C:\Program Files\AdoptOpenJDK\jdk-11.0.10.9-hotspot\jre\lib\ext\postgresql-42.2.18.jar”
  • 如果jre路径不存在“C:\Program Files\AdoptOpenJDK\jdk-11.0.10.9-hotspot”请创建文件夹

可以使用以下命令(使用命令提示符)检查安装:

1
java -version

命令输出结果:

1
2
3
4
C:\Users\User>java -version
openjdk version "11.0.xx"
OpenJDK Runtime Environment (AdoptOpenJDK)(...)
OpenJDK 64-Bit Server VM (AdoptOpenJDK)(...)

步骤2. 安装服务

下载安装包。

1
https://github.com/thingsboard/thingsboard/releases/download/v3.5.1/thingsboard-windows-3.5.1.zip

注意:我们假设你已将ThingsBoard软件包解压缩到默认位置:C:\Program Files (x86)\thingsboard

步骤3. 配置数据库

ThingsBoard能够使用SQL或hybrid数据库方式。
有关更多详细信息请参见相应的体系结构页面

ThingsBoard团队建议将PostgreSQL用于负载(<5000消息/秒)的开发和生产环境,使用公有云托管的PostgreSQL数据库服务对于某些ThingsBoard实例而言是一种经济高效的方式。

PostgreSQL安装

下载安装文件(PostgreSQL 11.7或更高版本)此处并按照安装说明进行操作。

在PostgreSQL安装时系统将提示您输入超级用户(postgres)密码。

请一定牢记此密码,为了方便记忆我们将密码替换为postgres。

创建ThingsBoard数据库

安装成功后启动”pgAdmin”并使用超级用户(postgres)身份登录。
打开服务器并用”postgres”用户创建数据库”thingsboard”。

ThingsBoard配置

如果已将PostgreSQL超级用户密码指定为”postgres”则可以跳过此步骤。

以管理员用户身份打开记事本或其他编辑器(右键单击应用程序图标然后选择”以管理员身份运行”)。
打开以下文件进行编辑(在文件选择对话框中选择“所有文件”而不是“文本文档”,编码为UTF-8):

1
C:\Program Files (x86)\thingsboard\conf\thingsboard.yml

找到”SQL DAO Configuration”代码块将postgres用户密码替换”postgres”:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# SQL DAO Configuration
spring:
  data:
    jpa:
      repositories:
        enabled: "true"
  jpa:
    open-in-view: "false"
    hibernate:
      ddl-auto: "none"
  datasource:
    driverClassName: "${SPRING_DRIVER_CLASS_NAME:org.postgresql.Driver}"
    url: "${SPRING_DATASOURCE_URL:jdbc:postgresql://localhost:5432/thingsboard}"
    username: "${SPRING_DATASOURCE_USERNAME:postgres}"
    password: "${SPRING_DATASOURCE_PASSWORD:YOUR_POSTGRES_PASSWORD_HERE}"
    hikari:
      maximumPoolSize: "${SPRING_DATASOURCE_MAXIMUM_POOL_SIZE:5}"

找到”SQL_POSTGRES_TS_KV_PARTITIONING”参数以覆盖时间戳键值存储分区大小的默认值:

1
2
3
4
    sql:
      postgres:
        # Specify partitioning size for timestamp key-value storage. Example: DAYS, MONTHS, YEARS, INDEFINITE.
        ts_key_value_partitioning: "${SQL_POSTGRES_TS_KV_PARTITIONING:MONTHS}"

ThingsBoard团队建议具有在生产环境使用TimescaleDB经验的公司使用Timescale数据库把时间序列数据存储在TimescaleDB Hypertable中并将PostgreSQL用于主要实体(设备/资产/仪表板/客户)。

PostgreSQL安装

下载安装文件(PostgreSQL 11.7或更高版本)此处并按照安装说明进行操作。

在PostgreSQL安装时系统将提示您输入超级用户(postgres)密码。

请一定牢记此密码,为了方便记忆我们将密码替换为postgres。

创建ThingsBoard数据库

安装成功后启动”pgAdmin”并使用超级用户(postgres)身份登录。
打开服务器并用”postgres”用户创建数据库”thingsboard”。

ThingsBoard配置

以管理员用户身份打开记事本或其他编辑器(右键单击应用程序图标然后选择”以管理员身份运行”)。
打开以下文件进行编辑(在文件选择对话框中选择“所有文件”而不是“文本文档”,编码为UTF-8):

1
C:\Program Files (x86)\thingsboard\conf\thingsboard.yml

找到”SQL DAO Configuration”代码块将postgres用户密码替换”postgres”:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# SQL DAO Configuration
spring:
  data:
    jpa:
      repositories:
        enabled: "true"
  jpa:
    open-in-view: "false"
    hibernate:
      ddl-auto: "none"
  datasource:
    driverClassName: "${SPRING_DRIVER_CLASS_NAME:org.postgresql.Driver}"
    url: "${SPRING_DATASOURCE_URL:jdbc:postgresql://localhost:5432/thingsboard}"
    username: "${SPRING_DATASOURCE_USERNAME:postgres}"
    password: "${SPRING_DATASOURCE_PASSWORD:YOUR_POSTGRES_PASSWORD_HERE}"
    hikari:
      maximumPoolSize: "${SPRING_DATASOURCE_MAXIMUM_POOL_SIZE:5}"

找到”DATABASE_TS_TYPE”参数将”sql”替换为”timescale”。

1
2
3
4
      ts:
        type: "${DATABASE_TS_TYPE:sql}" # cassandra, sql, or timescale (for hybrid mode, DATABASE_TS_TYPE value should be cassandra, or timescale)
    
    # note: timescale works only with postgreSQL database for DATABASE_ENTITIES_TYPE.

可以选择调整引用Timescale DB配置的参数”sql”配置块中的”timescale”配置块。

1
2
3
4
5
# SQL configuration parameters
sql:
    timescale:
      # Specify Interval size for new data chunks storage.
      chunk_time_interval: "${SQL_TIMESCALE_CHUNK_TIME_INTERVAL:604800000}"

步骤4. 选择消息队列服务

ThingsBoard使用消息系统存储服务之间的通信,请正确选择队列?

  • 内存 适用于开发环境(开发)

  • Kafka 适用于生产环境(集群)

  • RabbitMQ 适用生产环境(单体)

  • AWS SQS 适用生产环境(AWS公有云)

  • Google发布/订阅 适用生产环境(Google公有云)

  • Azure服务总线 适用生产环境(Azure公有云)

  • Confluent云 适用于生产环境(托管)

参见相应的架构页面和规则引擎页面以获取更多详细信息。

默认使用内存队列无需其他配置。

Kafka安装

Apache Kafka是一个开源的流式数据处理平台。

ZooKeeper安装

Kafka基于ZooKeeper运行需要先安装 ZooKeeper 服务:

1
sudo apt-get install zookeeper
Kafka安装
1
2
3
4
5
wget https://archive.apache.org/dist/kafka/2.6.0/kafka_2.13-2.6.0.tgz

tar xzf kafka_2.13-2.6.0.tgz

sudo mv kafka_2.13-2.6.0 /usr/local/kafka
设置ZooKeeper启动服务

创建一个Zookeeper系统文件:

1
sudo nano /etc/systemd/system/zookeeper.service

Add below contnet:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[Unit]
Description=Apache Zookeeper server
Documentation=http://zookeeper.apache.org
Requires=network.target remote-fs.target
After=network.target remote-fs.target

[Service]
Type=simple
ExecStart=/usr/local/kafka/bin/zookeeper-server-start.sh /usr/local/kafka/config/zookeeper.properties
ExecStop=/usr/local/kafka/bin/zookeeper-server-stop.sh
Restart=on-abnormal

[Install]
WantedBy=multi-user.target
设置Kafka启动服务

创建一个Kafka系统文件:

1
sudo nano /etc/systemd/system/kafka.service

添加以下内容替换系统的“PUT_YOUR_JAVA_PATH”为实际的JAVA_HOME路径默认路径是“/usr/lib/jvm/java-11-openjdk-xxx”:

1
2
3
4
5
6
7
8
9
10
11
12
13
[Unit]
Description=Apache Kafka Server
Documentation=http://kafka.apache.org/documentation.html
Requires=zookeeper.service

[Service]
Type=simple
Environment="JAVA_HOME=PUT_YOUR_JAVA_PATH"
ExecStart=/usr/local/kafka/bin/kafka-server-start.sh /usr/local/kafka/config/server.properties
ExecStop=/usr/local/kafka/bin/kafka-server-stop.sh

[Install]
WantedBy=multi-user.target
启动 ZooKeeper 和 Kafka:
1
2
3
sudo systemctl start zookeeper

sudo systemctl start kafka
ThingsBoard配置

编辑配置文件

1
sudo nano /etc/thingsboard/conf/thingsboard.conf

添加下面配置并将”localhost:9092”替换成真实的Kafka服务器地址:

1
2
export TB_QUEUE_TYPE=kafka
export TB_KAFKA_SERVERS=localhost:9092

AWS SQS配置

首先需要创建AWS账户然后访问AWS SQS服务。

使用此说明创建AWS SQS服务凭证。

  • Access key ID
  • Secret access key
ThingsBoard配置

编辑配置文件

1
sudo nano /etc/thingsboard/conf/thingsboard.conf

添加配置将”YOUR_KEY”和”YOUR_SECRET”替换为真实的AWS用户凭证并将”YOUR_REGION”替换成AWS SQS帐户区域:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
export TB_QUEUE_TYPE=aws-sqs
export TB_QUEUE_AWS_SQS_ACCESS_KEY_ID=YOUR_KEY
export TB_QUEUE_AWS_SQS_SECRET_ACCESS_KEY=YOUR_SECRET
export TB_QUEUE_AWS_SQS_REGION=YOUR_REGION

# These params affect the number of requests per second from each partitions per each queue.
# Number of requests to particular Message Queue is calculated based on the formula:
# ((Number of Rule Engine and Core Queues) * (Number of partitions per Queue) + (Number of transport queues)
#  + (Number of microservices) + (Number of JS executors)) * 1000 / POLL_INTERVAL_MS
# For example, number of requests based on default parameters is:

# Rule Engine queues:
# Main 10 partitions + HighPriority 10 partitions + SequentialByOriginator 10 partitions = 30
# Core queue 10 partitions
# Transport request Queue + response Queue = 2
# Rule Engine Transport notifications Queue + Core Transport notifications Queue = 2
# Total = 44
# Number of requests per second = 44 * 1000 / 25 = 1760 requests

# Based on the use case, you can compromise latency and decrease number of partitions/requests to the queue, if the message load is low.
# By UI set the parameters - interval (1000) and partitions (1) for Rule Engine queues.
# Sample parameters to fit into 10 requests per second on a "monolith" deployment: 

export TB_QUEUE_CORE_POLL_INTERVAL_MS=1000
export TB_QUEUE_CORE_PARTITIONS=2
export TB_QUEUE_RULE_ENGINE_POLL_INTERVAL_MS=1000
export TB_QUEUE_TRANSPORT_REQUEST_POLL_INTERVAL_MS=1000
export TB_QUEUE_TRANSPORT_RESPONSE_POLL_INTERVAL_MS=1000
export TB_QUEUE_TRANSPORT_NOTIFICATIONS_POLL_INTERVAL_MS=1000
export TB_QUEUE_VC_INTERVAL_MS=1000
export TB_QUEUE_VC_PARTITIONS=1

可以使用UI更新默认规则引擎队列配置(轮询间隔和分区)有关ThingsBoard规则引擎队列的更多信息请参阅文档

Google发布/订阅配置

创建一个Google帐户并访问发布/订阅服务。

使用此说明创建一个项目并使用发布/订阅服务。

使用此说明创建服务帐户凭据并编辑角色管理员后保存json凭据步骤9的文件此处

ThingsBoard配置

编辑配置文件

1
sudo nano /etc/thingsboard/conf/thingsboard.conf

添加下面配置内容使用真正用户密码替换“YOUR_PROJECT_ID”, “YOUR_SERVICE_ACCOUNT”:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
export TB_QUEUE_TYPE=pubsub
export TB_QUEUE_PUBSUB_PROJECT_ID=YOUR_PROJECT_ID
export TB_QUEUE_PUBSUB_SERVICE_ACCOUNT=YOUR_SERVICE_ACCOUNT

# These params affect the number of requests per second from each partitions per each queue.
# Number of requests to particular Message Queue is calculated based on the formula:
# ((Number of Rule Engine and Core Queues) * (Number of partitions per Queue) + (Number of transport queues)
#  + (Number of microservices) + (Number of JS executors)) * 1000 / POLL_INTERVAL_MS
# For example, number of requests based on default parameters is:

# Rule Engine queues:
# Main 10 partitions + HighPriority 10 partitions + SequentialByOriginator 10 partitions = 30
# Core queue 10 partitions
# Transport request Queue + response Queue = 2
# Rule Engine Transport notifications Queue + Core Transport notifications Queue = 2
# Total = 44
# Number of requests per second = 44 * 1000 / 25 = 1760 requests

# Based on the use case, you can compromise latency and decrease number of partitions/requests to the queue, if the message load is low.
# By UI set the parameters - interval (1000) and partitions (1) for Rule Engine queues.
# Sample parameters to fit into 10 requests per second on a "monolith" deployment: 

export TB_QUEUE_CORE_POLL_INTERVAL_MS=1000
export TB_QUEUE_CORE_PARTITIONS=2
export TB_QUEUE_RULE_ENGINE_POLL_INTERVAL_MS=1000
export TB_QUEUE_TRANSPORT_REQUEST_POLL_INTERVAL_MS=1000
export TB_QUEUE_TRANSPORT_RESPONSE_POLL_INTERVAL_MS=1000
export TB_QUEUE_TRANSPORT_NOTIFICATIONS_POLL_INTERVAL_MS=1000
export TB_QUEUE_VC_INTERVAL_MS=1000
export TB_QUEUE_VC_PARTITIONS=1

可以使用UI更新默认规则引擎队列配置(轮询间隔和分区)有关ThingsBoard规则引擎队列的更多信息请参阅文档

Azure服务总线配置

创建Azure帐户并访问Azure服务总线。

通过使用说明了解并使用总线服务。

使用说明创建共享访问签名。

ThingsBoard配置

编辑配置文件

1
sudo nano /etc/thingsboard/conf/thingsboard.conf

添加下面配置内容使用真正的服务总线名称空间替换”YOUR_NAMESPACE_NAME”和”YOUR_SAS_KEY_NAME”及”YOUR_SAS_KEY”:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
export TB_QUEUE_TYPE=service-bus
export TB_QUEUE_SERVICE_BUS_NAMESPACE_NAME=YOUR_NAMESPACE_NAME
export TB_QUEUE_SERVICE_BUS_SAS_KEY_NAME=YOUR_SAS_KEY_NAME
export TB_QUEUE_SERVICE_BUS_SAS_KEY=YOUR_SAS_KEY

# These params affect the number of requests per second from each partitions per each queue.
# Number of requests to particular Message Queue is calculated based on the formula:
# ((Number of Rule Engine and Core Queues) * (Number of partitions per Queue) + (Number of transport queues)
#  + (Number of microservices) + (Number of JS executors)) * 1000 / POLL_INTERVAL_MS
# For example, number of requests based on default parameters is:

# Rule Engine queues:
# Main 10 partitions + HighPriority 10 partitions + SequentialByOriginator 10 partitions = 30
# Core queue 10 partitions
# Transport request Queue + response Queue = 2
# Rule Engine Transport notifications Queue + Core Transport notifications Queue = 2
# Total = 44
# Number of requests per second = 44 * 1000 / 25 = 1760 requests

# Based on the use case, you can compromise latency and decrease number of partitions/requests to the queue, if the message load is low.
# By UI set the parameters - interval (1000) and partitions (1) for Rule Engine queues.
# Sample parameters to fit into 10 requests per second on a "monolith" deployment: 

export TB_QUEUE_CORE_POLL_INTERVAL_MS=1000
export TB_QUEUE_CORE_PARTITIONS=2
export TB_QUEUE_RULE_ENGINE_POLL_INTERVAL_MS=1000
export TB_QUEUE_TRANSPORT_REQUEST_POLL_INTERVAL_MS=1000
export TB_QUEUE_TRANSPORT_RESPONSE_POLL_INTERVAL_MS=1000
export TB_QUEUE_TRANSPORT_NOTIFICATIONS_POLL_INTERVAL_MS=1000
export TB_QUEUE_VC_INTERVAL_MS=1000
export TB_QUEUE_VC_PARTITIONS=1

可以使用UI更新默认规则引擎队列配置(轮询间隔和分区)有关ThingsBoard规则引擎队列的更多信息请参阅文档

RabbitMQ安装

你可以使用官方文档安装RabbitMQ或按照以下说明:

由于RabbitMQ是用Erlang编写的因此需要先安装Erlang才能使用RabbitMQ:

1
sudo apt-get install erlang

安装rabbitmq:

1
sudo apt-get install rabbitmq-server

启动服务

1
2
sudo systemctl start rabbitmq-server.service
sudo systemctl enable rabbitmq-server.service

RabbitMQ会默认创建一个名为”guest”的用户密码为”guest”。
你还可以使用以下命令在RabbitMQ服务器上创建自己的管理员帐户。
替换对应用户名和密码“PUT_YOUR_USER_NAME”和”PUT_YOUR_PASSWORD”:

1
2
3
sudo rabbitmqctl add_user PUT_YOUR_USER_NAME PUT_YOUR_PASSWORD 
sudo rabbitmqctl set_user_tags PUT_YOUR_USER_NAME administrator
sudo rabbitmqctl set_permissions -p / PUT_YOUR_USER_NAME ".*" ".*" ".*"
ThingsBoard配置

编辑配置文件

1
sudo nano /etc/thingsboard/conf/thingsboard.conf

将以下行添加到配置文件将“YOUR_USERNAME”和“YOUR_PASSWORD”替换为真实的信息将“localhost”和“5672”替换为真实的RabbitMQ主机和端口

1
2
3
4
5
export TB_QUEUE_TYPE=rabbitmq
export TB_QUEUE_RABBIT_MQ_USERNAME=YOUR_USERNAME
export TB_QUEUE_RABBIT_MQ_PASSWORD=YOUR_PASSWORD
export TB_QUEUE_RABBIT_MQ_HOST=localhost
export TB_QUEUE_RABBIT_MQ_PORT=5672

Confluent配置

你应该创建一个帐户后访问Confluent云然后创建一个Kafka集群API Key

ThingsBoard配置

编辑配置文件

1
sudo nano /etc/thingsboard/conf/thingsboard.conf

添加下面配置内容使用真正的Confluent云服务器地址替换”CLUSTER_API_KEY”, “CLUSTER_API_SECRET”和”localhost:9092”:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
export TB_QUEUE_TYPE=kafka
export TB_QUEUE_KAFKA_USE_CONFLUENT_CLOUD=true
export TB_KAFKA_SERVERS=localhost:9092
export TB_QUEUE_KAFKA_REPLICATION_FACTOR=3
export TB_QUEUE_KAFKA_CONFLUENT_SASL_JAAS_CONFIG=org.apache.kafka.common.security.plain.PlainLoginModule required username="CLUSTER_API_KEY" password="CLUSTER_API_SECRET";}

# These params affect the number of requests per second from each partitions per each queue.
# Number of requests to particular Message Queue is calculated based on the formula:
# ((Number of Rule Engine and Core Queues) * (Number of partitions per Queue) + (Number of transport queues)
#  + (Number of microservices) + (Number of JS executors)) * 1000 / POLL_INTERVAL_MS
# For example, number of requests based on default parameters is:

# Rule Engine queues:
# Main 10 partitions + HighPriority 10 partitions + SequentialByOriginator 10 partitions = 30
# Core queue 10 partitions
# Transport request Queue + response Queue = 2
# Rule Engine Transport notifications Queue + Core Transport notifications Queue = 2
# Total = 44
# Number of requests per second = 44 * 1000 / 25 = 1760 requests

# Based on the use case, you can compromise latency and decrease number of partitions/requests to the queue, if the message load is low.
# By UI set the parameters - interval (1000) and partitions (1) for Rule Engine queues.
# Sample parameters to fit into 10 requests per second on a "monolith" deployment: 

export TB_QUEUE_CORE_POLL_INTERVAL_MS=1000
export TB_QUEUE_CORE_PARTITIONS=2
export TB_QUEUE_RULE_ENGINE_POLL_INTERVAL_MS=1000
export TB_QUEUE_TRANSPORT_REQUEST_POLL_INTERVAL_MS=1000
export TB_QUEUE_TRANSPORT_RESPONSE_POLL_INTERVAL_MS=1000
export TB_QUEUE_TRANSPORT_NOTIFICATIONS_POLL_INTERVAL_MS=1000
export TB_QUEUE_VC_INTERVAL_MS=1000
export TB_QUEUE_VC_PARTITIONS=1

可以使用UI更新默认规则引擎队列配置(轮询间隔和分区)有关ThingsBoard规则引擎队列的更多信息请参阅文档

步骤5. [可选]低性能配置(1GB内存)

以管理员用户身份打开记事本或其他编辑器(右键单击应用程序图标,然后选择“以管理员身份运行”)。
打开以下文件进行编辑(在文件选择对话框中选择“所有文件”而不是“文本文档”,编码为UTF-8):

1
C:\Program Files (x86)\thingsboard\thingsboard.xml

在配置文件中找到以下几行。

1
2
    <startargument>-Xms512m</startargument>
    <startargument>-Xmx1024m</startargument>

并将它们更改为

1
2
    <startargument>-Xms256m</startargument>
    <startargument>-Xmx256m</startargument>

步骤6. 运行安装脚本

以管理员身份启动Windows Shell(命令提示符)将目录更改为ThingsBoard安装目录。

执行install.bat脚本将ThingsBoard作为Windows服务安装(或运行“install.bat –loadDemo”以安装和添加演示数据)。
这样在系统启动时自动启动服务。
执行uninstall.bat将从Windows服务中删除ThingsBoard。

输出以下内容:

1
2
3
4
5
6
7
C:\Program Files (x86)\thingsboard>install.bat --loadDemo
Detecting Java version installed.
CurrentVersion 110
Java 11 found!
Installing thingsboard ...
...
ThingsBoard installed successfully!

步骤7. 启动服务

现在开始启动ThingsBoard服务! 以管理员身份打开命令提示符并执行以下命令:

1
net start thingsboard

执行输出结果:

1
2
The ThingsBoard Server Application service is starting.
The ThingsBoard Server Application service was started successfully.

可以执行以下命令重新启动ThingsBoard服务:

1
2
net stop thingsboard
net start thingsboard

启动后使用以下链接打开Web UI:

1
http://localhost:8080/

如果在安装脚本的执行过程中指定了-loadDemo则可以使用以下默认帐号:

  • System Administrator: sysadmin@thingsboard.org / sysadmin
  • Tenant Administrator: tenant@thingsboard.org / tenant
  • Customer User: customer@thingsboard.org / customer

可以在帐户详情页面中更改每个帐户的密码。

如果是1-2核CPU或1-2G内存的计算机请等待90秒后启动界面。

故障排查

日志文件位于logs文件夹中(本例中为”C:\Program Files (x86)\thingsboard\logs”)。

thingsboard.log文件应包含以下行:

1
2
YYYY-MM-DD HH:mm:ss,sss [main] INFO  o.t.s.ThingsboardServerApplication - Started ThingsboardServerApplication in x.xxx seconds (JVM running for x.xxx)

如果出现任何不清楚的错误请使用常见的故障指南联系我们

Windows防火强设置

从外部访问ThingsBoard和设备连接(HTTP,MQTT,CoAP)使用Windows防火墙创建新的入站规则。

  • 打开Windows控制面板:

image

  • 点击左侧面板上的”高级设置”:

image

  • 在左侧面板上选择“入站规则”,然后在右侧“操作”面板上单击“新建规则…”:

image

  • 现在将打开新的“新建入站规则向导”窗口。在第一步“规则类型”中选择“端口”选项:

image

  • 在“协议和端口”步骤中选择“TCP”协议然后在“特定本地端口”字段中输入端口列表8080、1883、5683

image

  • 在“操作”步骤中选择“允许连接”选项:

image

  • 在“配置文件”步骤中选择何时应用此规则的Windows网络配置文件:

image

  • 最后为该规则命名(例如“ ThingsBoard服务网络”)然后单击“完成”。

image

下一步

  • 入门指南 - 快速学习ThingsBoard相关功能。

  • 连接设备 - 学习如何根据你的连接方式或解决方案连接设备。

  • 可 视 化 - 学习如何配置复杂的ThingsBoard仪表板说明。

  • 数据处理 - 学习如何使用ThingsBoard规则引擎。

  • 数据分析 - 学习如何使用规则引擎执行基本的分析任务。

  • 硬件样品 - 学习如何将各种硬件平台连接到ThingsBoard。

  • 高级功能 - 学习高级ThingsBoard功能。

  • 开发指南 - 学习ThingsBoard中的贡献和开发。