This guide will help you to install and start ThingsBoard Professional Edition (PE) using Docker and Docker Compose on Linux or Mac OS.
This guide covers standalone ThingsBoard PE installation.
If you are looking for a cluster installation instruction, please visit cluster setup page.
Prerequisites
Step 1. Pull ThingsBoard PE Image
1
| docker pull thingsboard/tb-pe:3.5.1PE
|
Step 2. Obtain the license key
We assume you have already chosen your subscription plan or decided to purchase a perpetual license.
If not, please navigate to pricing page to select the best license option for your case and get your license.
See How-to get pay-as-you-go subscription or How-to get perpetual license for more details.
Note: We will reference the license key you have obtained during this step as PUT_YOUR_LICENSE_SECRET_HERE later in this guide.
Step 3. Choose ThingsBoard queue service
ThingsBoard使用消息系统存储服务之间的通信,请正确选择队列?
参见相应的架构页面和规则引擎页面以获取更多详细信息。
ThingsBoard默认使用内存队列服务无需额外设置。
创建docker compose文件:
1
| nano docker-compose.yml
|
Add the following line to the yml file. Don’t forget to replace “PUT_YOUR_LICENSE_SECRET_HERE” with your license secret obtained on the first step:
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
| version: '3.0'
services:
mytbpe:
restart: always
image: "thingsboard/tb-pe:3.5.1PE"
ports:
- "8080:8080"
- "1883:1883"
- "7070:7070"
- "5683-5688:5683-5688/udp"
environment:
TB_QUEUE_TYPE: in-memory
SPRING_DATASOURCE_URL: jdbc:postgresql://postgres:5432/thingsboard
TB_LICENSE_SECRET: PUT_YOUR_LICENSE_SECRET_HERE
TB_LICENSE_INSTANCE_DATA_FILE: /data/license.data
volumes:
- ~/.mytbpe-data:/data
- ~/.mytbpe-logs:/var/log/thingsboard
postgres:
restart: always
image: "postgres:12"
ports:
- "5432"
environment:
POSTGRES_DB: thingsboard
POSTGRES_PASSWORD: postgres
volumes:
- ~/.mytbpe-data/db:/var/lib/postgresql/data
|
|
Apache Kafka是一个开源的流式数据处理平台。
创建docker compose文件:
1
| nano docker-compose.yml
|
Add the following line to the yml file. Don’t forget to replace “PUT_YOUR_LICENSE_SECRET_HERE” with your license secret obtained on the first step:
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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
| version: '3.0'
services:
zookeeper:
restart: always
image: "zookeeper:3.5"
ports:
- "2181:2181"
environment:
ZOO_MY_ID: 1
ZOO_SERVERS: server.1=zookeeper:2888:3888;zookeeper:2181
kafka:
restart: always
image: wurstmeister/kafka
depends_on:
- zookeeper
ports:
- "9092:9092"
environment:
KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
KAFKA_LISTENERS: INSIDE://:9093,OUTSIDE://:9092
KAFKA_ADVERTISED_LISTENERS: INSIDE://:9093,OUTSIDE://kafka:9092
KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: INSIDE:PLAINTEXT,OUTSIDE:PLAINTEXT
KAFKA_INTER_BROKER_LISTENER_NAME: INSIDE
volumes:
- /var/run/docker.sock:/var/run/docker.sock
mytbpe:
restart: always
image: "thingsboard/tb-pe:3.5.1PE"
depends_on:
- kafka
ports:
- "8080:8080"
- "1883:1883"
- "7070:7070"
- "5683-5688:5683-5688/udp"
environment:
TB_QUEUE_TYPE: kafka
SPRING_DATASOURCE_URL: jdbc:postgresql://postgres:5432/thingsboard
TB_KAFKA_SERVERS: kafka:9092
TB_LICENSE_SECRET: PUT_YOUR_LICENSE_SECRET_HERE
TB_LICENSE_INSTANCE_DATA_FILE: /data/license.data
volumes:
- ~/.mytbpe-data:/data
- ~/.mytbpe-logs:/var/log/thingsboard
postgres:
restart: always
image: "postgres:12"
ports:
- "5432"
environment:
POSTGRES_DB: thingsboard
POSTGRES_PASSWORD: postgres
volumes:
- ~/.mytbpe-data/db:/var/lib/postgresql/data
|
|
AWS SQS配置
首先需要创建AWS账户然后访问AWS SQS服务。
使用此说明创建AWS SQS服务凭证。
- Access key ID
- Secret access key
创建docker compose文件:
1
| nano docker-compose.yml
|
添加配置将”YOUR_KEY”和”YOUR_SECRET”替换为真实的AWS用户凭证并将”YOUR_REGION”替换成AWS SQS帐户区域:and “PUT_YOUR_LICENSE_SECRET_HERE” with your license secret obtained on the first step:
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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
| version: '3.0'
services:
mytbpe:
restart: always
image: "thingsboard/tb-pe:3.5.1PE"
ports:
- "8080:8080"
- "1883:1883"
- "7070:7070"
- "5683-5688:5683-5688/udp"
environment:
TB_QUEUE_TYPE: aws-sqs
SPRING_DATASOURCE_URL: jdbc:postgresql://postgres:5432/thingsboard
TB_QUEUE_AWS_SQS_ACCESS_KEY_ID: YOUR_KEY
TB_QUEUE_AWS_SQS_SECRET_ACCESS_KEY: YOUR_SECRET
TB_QUEUE_AWS_SQS_REGION: YOUR_REGION
TB_LICENSE_SECRET: PUT_YOUR_LICENSE_SECRET_HERE
TB_LICENSE_INSTANCE_DATA_FILE: /data/license.data
# 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:
TB_QUEUE_CORE_POLL_INTERVAL_MS: 1000
TB_QUEUE_CORE_PARTITIONS: 2
TB_QUEUE_RULE_ENGINE_POLL_INTERVAL_MS: 1000
TB_QUEUE_TRANSPORT_REQUEST_POLL_INTERVAL_MS: 1000
TB_QUEUE_TRANSPORT_RESPONSE_POLL_INTERVAL_MS: 1000
TB_QUEUE_TRANSPORT_NOTIFICATIONS_POLL_INTERVAL_MS: 1000
TB_QUEUE_VC_INTERVAL_MS: 1000
TB_QUEUE_VC_PARTITIONS: 1
volumes:
- ~/.mytbpe-data:/data
- ~/.mytbpe-logs:/var/log/thingsboard
postgres:
restart: always
image: "postgres:12"
ports:
- "5432"
environment:
POSTGRES_DB: thingsboard
POSTGRES_PASSWORD: postgres
volumes:
- ~/.mytbpe-data/db:/var/lib/postgresql/data
|
可以使用UI更新默认规则引擎队列配置(轮询间隔和分区)有关ThingsBoard规则引擎队列的更多信息请参阅文档。
|
Google发布/订阅配置
创建一个Google帐户并访问发布/订阅服务。
使用此说明创建一个项目并使用发布/订阅服务。
使用此说明创建服务帐户凭据并编辑角色或管理员后保存json凭据步骤9的文件此处。
创建docker compose文件:
1
| nano docker-compose.yml
|
添加下面配置内容使用真正用户密码替换“YOUR_PROJECT_ID”, “YOUR_SERVICE_ACCOUNT”:and “PUT_YOUR_LICENSE_SECRET_HERE” with your license secret obtained on the first step:
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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
| version: '3.0'
services:
mytbpe:
restart: always
image: "thingsboard/tb-pe:3.5.1PE"
ports:
- "8080:8080"
- "1883:1883"
- "7070:7070"
- "5683-5688:5683-5688/udp"
environment:
TB_QUEUE_TYPE: pubsub
SPRING_DATASOURCE_URL: jdbc:postgresql://postgres:5432/thingsboard
TB_QUEUE_PUBSUB_PROJECT_ID: YOUR_PROJECT_ID
TB_QUEUE_PUBSUB_SERVICE_ACCOUNT: YOUR_SERVICE_ACCOUNT
TB_LICENSE_SECRET: PUT_YOUR_LICENSE_SECRET_HERE
TB_LICENSE_INSTANCE_DATA_FILE: /data/license.data
# 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:
TB_QUEUE_CORE_POLL_INTERVAL_MS: 1000
TB_QUEUE_CORE_PARTITIONS: 2
TB_QUEUE_RULE_ENGINE_POLL_INTERVAL_MS: 1000
TB_QUEUE_TRANSPORT_REQUEST_POLL_INTERVAL_MS: 1000
TB_QUEUE_TRANSPORT_RESPONSE_POLL_INTERVAL_MS: 1000
TB_QUEUE_TRANSPORT_NOTIFICATIONS_POLL_INTERVAL_MS: 1000
TB_QUEUE_VC_INTERVAL_MS: 1000
TB_QUEUE_VC_PARTITIONS: 1
volumes:
- ~/.mytbpe-data:/data
- ~/.mytbpe-logs:/var/log/thingsboard
postgres:
restart: always
image: "postgres:12"
ports:
- "5432"
environment:
POSTGRES_DB: thingsboard
POSTGRES_PASSWORD: postgres
volumes:
- ~/.mytbpe-data/db:/var/lib/postgresql/data
|
可以使用UI更新默认规则引擎队列配置(轮询间隔和分区)有关ThingsBoard规则引擎队列的更多信息请参阅文档。
|
Azure服务总线配置
创建Azure帐户并访问Azure服务总线。
通过使用说明了解并使用总线服务。
使用说明创建共享访问签名。
创建docker compose文件:
1
| nano docker-compose.yml
|
添加下面配置内容使用真正的服务总线名称空间替换”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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
| version: '3.0'
services:
mytbpe:
restart: always
image: "thingsboard/tb-pe:3.5.1PE"
ports:
- "8080:8080"
- "1883:1883"
- "7070:7070"
- "5683-5688:5683-5688/udp"
environment:
TB_QUEUE_TYPE: service-bus
SPRING_DATASOURCE_URL: jdbc:postgresql://postgres:5432/thingsboard
TB_QUEUE_SERVICE_BUS_NAMESPACE_NAME: YOUR_NAMESPACE_NAME
TB_QUEUE_SERVICE_BUS_SAS_KEY_NAME: YOUR_SAS_KEY_NAME
TB_QUEUE_SERVICE_BUS_SAS_KEY: YOUR_SAS_KEY
TB_LICENSE_SECRET: PUT_YOUR_LICENSE_SECRET_HERE
TB_LICENSE_INSTANCE_DATA_FILE: /data/license.data
# 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:
TB_QUEUE_CORE_POLL_INTERVAL_MS: 1000
TB_QUEUE_CORE_PARTITIONS: 2
TB_QUEUE_RULE_ENGINE_POLL_INTERVAL_MS: 1000
TB_QUEUE_TRANSPORT_REQUEST_POLL_INTERVAL_MS: 1000
TB_QUEUE_TRANSPORT_RESPONSE_POLL_INTERVAL_MS: 1000
TB_QUEUE_TRANSPORT_NOTIFICATIONS_POLL_INTERVAL_MS: 1000
TB_QUEUE_VC_INTERVAL_MS: 1000
TB_QUEUE_VC_PARTITIONS: 1
volumes:
- ~/.mytbpe-data:/data
- ~/.mytbpe-logs:/var/log/thingsboard
postgres:
restart: always
image: "postgres:12"
ports:
- "5432"
environment:
POSTGRES_DB: thingsboard
POSTGRES_PASSWORD: postgres
volumes:
- ~/.mytbpe-data/db:/var/lib/postgresql/data
|
可以使用UI更新默认规则引擎队列配置(轮询间隔和分区)有关ThingsBoard规则引擎队列的更多信息请参阅文档。
|
你可以使用官方文档安装RabbitMQ或按照以下说明:
创建docker compose文件:
1
| nano docker-compose.yml
|
Add the following line to the yml file. Don’t forget to replace “YOUR_USERNAME” and “YOUR_PASSWORD” with your real user credentials, “localhost” and “5672” with your real RabbitMQ host and port, and “PUT_YOUR_LICENSE_SECRET_HERE” with your license secret obtained on the first step:
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
| version: '3.0'
services:
mytbpe:
restart: always
image: "thingsboard/tb-pe:3.5.1PE"
ports:
- "8080:8080"
- "1883:1883"
- "7070:7070"
- "5683-5688:5683-5688/udp"
environment:
TB_QUEUE_TYPE: rabbitmq
SPRING_DATASOURCE_URL: jdbc:postgresql://postgres:5432/thingsboard
TB_QUEUE_RABBIT_MQ_USERNAME: YOUR_USERNAME
TB_QUEUE_RABBIT_MQ_PASSWORD: YOUR_PASSWORD
TB_QUEUE_RABBIT_MQ_HOST: localhost
TB_QUEUE_RABBIT_MQ_PORT: 5672
TB_LICENSE_SECRET: PUT_YOUR_LICENSE_SECRET_HERE
TB_LICENSE_INSTANCE_DATA_FILE: /data/license.data
volumes:
- ~/.mytbpe-data:/data
- ~/.mytbpe-logs:/var/log/thingsboard
postgres:
restart: always
image: "postgres:12"
ports:
- "5432"
environment:
POSTGRES_DB: thingsboard
POSTGRES_PASSWORD: postgres
volumes:
- ~/.mytbpe-data/db:/var/lib/postgresql/data
|
|
Confluent配置
你应该创建一个帐户后访问Confluent云然后创建一个Kafka集群和 API Key。
创建docker compose文件:
1
| nano docker-compose.yml
|
添加下面配置内容使用真正的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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
| version: '3.0'
services:
mytbpe:
restart: always
image: "thingsboard/tb-pe:3.5.1PE"
ports:
- "8080:8080"
- "1883:1883"
- "7070:7070"
- "5683-5688:5683-5688/udp"
environment:
TB_QUEUE_TYPE=kafka
SPRING_DATASOURCE_URL: jdbc:postgresql://postgres:5432/thingsboard
TB_KAFKA_SERVERS:confluent.cloud:9092
TB_QUEUE_KAFKA_REPLICATION_FACTOR:3
TB_QUEUE_KAFKA_USE_CONFLUENT_CLOUD:true
TB_QUEUE_KAFKA_CONFLUENT_SSL_ALGORITHM:https
TB_QUEUE_KAFKA_CONFLUENT_SASL_MECHANISM:PLAIN
TB_QUEUE_KAFKA_CONFLUENT_SASL_JAAS_CONFIG:org.apache.kafka.common.security.plain.PlainLoginModule required username="CLUSTER_API_KEY" password="CLUSTER_API_SECRET";
TB_QUEUE_KAFKA_CONFLUENT_SECURITY_PROTOCOL:SASL_SSL
TB_QUEUE_KAFKA_CONFLUENT_USERNAME:CLUSTER_API_KEY
TB_QUEUE_KAFKA_CONFLUENT_PASSWORD:CLUSTER_API_SECRET
TB_QUEUE_KAFKA_RE_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:52428800;retention.bytes:1048576000
TB_QUEUE_KAFKA_CORE_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:52428800;retention.bytes:1048576000
TB_QUEUE_KAFKA_TA_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:52428800;retention.bytes:1048576000
TB_QUEUE_KAFKA_NOTIFICATIONS_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:52428800;retention.bytes:1048576000
TB_QUEUE_KAFKA_JE_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:52428800;retention.bytes:104857600
# 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:
TB_QUEUE_CORE_POLL_INTERVAL_MS: 1000
TB_QUEUE_CORE_PARTITIONS: 2
TB_QUEUE_RULE_ENGINE_POLL_INTERVAL_MS: 1000
TB_QUEUE_TRANSPORT_REQUEST_POLL_INTERVAL_MS: 1000
TB_QUEUE_TRANSPORT_RESPONSE_POLL_INTERVAL_MS: 1000
TB_QUEUE_TRANSPORT_NOTIFICATIONS_POLL_INTERVAL_MS: 1000
TB_QUEUE_VC_INTERVAL_MS: 1000
TB_QUEUE_VC_PARTITIONS: 1
volumes:
- ~/.mytbpe-data:/data
- ~/.mytbpe-logs:/var/log/thingsboard
postgres:
restart: always
image: "postgres:12"
ports:
- "5432"
environment:
POSTGRES_DB: thingsboard
POSTGRES_PASSWORD: postgres
volumes:
- ~/.mytbpe-data/db:/var/lib/postgresql/data
|
可以使用UI更新默认规则引擎队列配置(轮询间隔和分区)有关ThingsBoard规则引擎队列的更多信息请参阅文档。
|
Where:
PUT_YOUR_LICENSE_SECRET_HERE
- placeholder for your license secret obtained on the third step;
8080:8080
- connect local port 8080 to exposed internal HTTP port 8080;
1883:1883
- connect local port 1883 to exposed internal MQTT port 1883;
7070:7070
- connect local port 7070 to exposed internal Edge RPC port 7070;
5683-5688:5683-5688/udp
- connect local UDP ports 5683-5688 to exposed internal COAP and LwM2M ports;
~/.mytbpe-data:/data
- mounts the host’s dir ~/.mytbpe-data
to ThingsBoard data directory;
~/.mytbpe-data/db:/var/lib/postgresql/data
- mounts the host’s dir ~/.mytbpe-data/db
to Postgres data directory;
~/.mytbpe-logs:/var/log/thingsboard
- mounts the host’s dir ~/.mytbpe-logs
to ThingsBoard logs directory;
mytbpe
- friendly local name of this machine;
restart: always
- automatically start ThingsBoard in case of system reboot and restart in case of failure.;
thingsboard/tb-pe:3.5.1PE
- docker image.
Step 4. Running
在启动Docker容器之前请运行以下命令以创建用于存储数据和日志的目录然后将其所有者更改为Docker容器用户,以便能够更改用户使用chown命令该命令需要sudo权限(该命令将要求sudo访问的密码):
1
2
| mkdir -p ~/.mytbpe-data && sudo chown -R 799:799 ~/.mytbpe-data
mkdir -p ~/.mytbpe-logs && sudo chown -R 799:799 ~/.mytbpe-logs
|
NOTE: replace directory ~/.mytbpe-data
and ~/.mytbpe-logs
with directories you’re planning to used in docker-compose.yml
.
在包含该文件的目录终端中执行以下命令启动此docker compos:docker-compose.yml
1
2
3
| docker compose pull
docker compose up -d
docker compose logs -f mytbpe
|
ThingsBoard3.4.2版本开始支持Docker Compose V2(Docker Desktop或Compose插件)因为Docker不再支持docker-compose作为独立设置。
我们强烈建议更新到Docker Compose V2 使用它。
更新最新镜像docker-compose命令:
docker-compose pull
docker-compose up -d
docker-compose logs -f mytbpe
执行完命令后你可以http://{your-host-ip}:8080
在浏览器中打开(例如http://localhost:9090
)。
使用以下默认凭据:
- System Administrator: sysadmin@thingsboard.org / sysadmin
- Tenant Administrator: tenant@thingsboard.org / tenant
- Customer User: customer@thingsboard.org / customer
可以在帐户详情页面中更改每个帐户的密码。
Detaching, stop and start commands
你可以使用Ctrl-p
Ctrl-q
与会话终端分离容器将继续在后台运行。
如果出现任何问题可以检查服务日志中的错误例如:要查看ThingsBoard容器日志。
请执行以下命令:
1
| docker compose logs -f mytbpe
|
停止容器:
1
| docker compose stop mytbpe
|
启动容器:
1
| docker compose start mytbpe
|
Docker Compose已被弃用建议使用Docker Compose V2
更新最新镜像docker-compose命令:
docker-compose logs -f mytbpe
docker-compose stop mytbpe
docker-compose start mytbpe
Troubleshooting
DNS issues
注意:如果你发现与DNS问题相关的错误,例如
1
| 127.0.1.1:53: cannot unmarshal DNS message
|
你可以将系统配置为使用 Google公共DNS服务器。
请参阅相应的Linux和Mac OS说明
Upgrading from old PostgreSQL 9.6 to PostgreSQL 11 and ThingsBoard 3.0.1PE
In this example we’ll show steps to upgrade ThingsBoard from 2.4.3PE to 3.0.1PE.
Make a backup of your data:
1
| sudo cp -r ~/.mytbpe-data ./.mytbpe-data-2-4-3-backup
|
Stop currently running docker container:
1
| docker stop [container_id]
|
Upgrade old postgres to the new one:
1
2
3
| docker run --rm -v ~/.mytbpe-data/db/:/var/lib/postgresql/9.6/data -v ~/.mytbpe-data-temp/db/:/var/lib/postgresql/11/data --env LANG=C.UTF-8 tianon/postgres-upgrade:9.6-to-11
sudo rm -rf ~/.mytbpe-data/db
sudo mv ~/.mytbpe-data-temp/db ~/.mytbpe-data/db
|
Start the new version of TB with following command:
1
| docker run -it -v ~/.mytbpe-data:/data --rm thingsboard/tb-pe:3.0.1PE bash
|
Then please follow these steps:
1
2
3
4
5
6
7
8
9
10
| apt update
apt install sudo
chown -R postgres. /data/db/
chmod 750 -R /data/db/
sudo -i -u postgres
cd /usr/lib/postgresql/11/
./bin/pg_ctl -D /data/db start
logout
/usr/share/thingsboard/bin/install/upgrade.sh --fromVersion=2.4.1
exit
|
After this create your docker-compose.yml and insert (we used in-memory queue as an example):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| version: '3.0'
services:
mytbpe:
restart: always
image: "thingsboard/tb-pe:3.0.1PE"
ports:
- "8080:9090"
- "1883:1883"
- "7070:7070"
- "5683-5688:5683-5688/udp"
environment:
TB_QUEUE_TYPE: in-memory
TB_LICENSE_SECRET: YOUR_SECRET_KEY
TB_LICENSE_INSTANCE_DATA_FILE: /data/license.data
INTEGRATIONS_RPC_PORT: 50052
PGDATA: /data/db
volumes:
- ~/.mytbpe-data:/data
- ~/.mytbpe-logs:/var/log/thingsboard
|
Start ThingsBoard:
If you still rely on Docker Compose as docker-compose (with a hyphen) execute next command:
docker-compose up
Upgrading from 3.0.1PE to 3.1.0PE
After 3.0.1PE PostgreSQL service was separated from ThingsBoard image and upgrading to 3.1.0PE version is not trivial.
First of all you need to create a dump of your database:
1
| docker compose exec mytbpe sh -c "pg_dump -U postgres thingsboard > /data/thingsboard_dump"
|
If you still rely on Docker Compose as docker-compose (with a hyphen) execute next command:
docker-compose exec mytbpe sh -c “pg_dump -U postgres thingsboard > /data/thingsboard_dump”
Note You have to use your valid username for connecting to PostgreSQL
Then you need to stop service, create a new directory for the database and set permissions:
1
2
3
4
5
| sudo cp -r ~/.mytbpe-data ./.mytbpe-data-backup
docker compose down
sudo rm -rf ~/.mytbpe-data/db
sudo chown -R 799:799 ~/.mytbpe-data
sudo chown -R 799:799 ~/.mytbpe-logs
|
更新最新镜像docker-compose命令:
sudo cp -r ~/.mytbpe-data ./.mytbpe-data-backup
docker-compose down
sudo rm -rf ~/.mytbpe-data/db
sudo chown -R 799:799 ~/.mytbpe-data
sudo chown -R 799:799 ~/.mytbpe-logs
After this you need to update docker-compose.yml as in Step 4 but with 3.1.0PE instead of 3.5.1PE:
Start PostgreSQL:
1
| docker compose up postgres
|
If you still rely on Docker Compose as docker-compose (with a hyphen) execute next command:
docker-compose up postgres
Restore backup:
1
2
| sudo cp ~/.mytbpe-data/thingsboard_dump ~/.mytbpe-data/db/thingsboard_dump
docker compose exec postgres sh -c "psql -U postgres thingsboard < /var/lib/postgresql/data/thingsboard_dump"
|
更新最新镜像docker-compose命令:
sudo cp ~/.mytbpe-data/thingsboard_dump ~/.mytbpe-data/db/thingsboard_dump
docker-compose exec postgres sh -c “psql -U postgres thingsboard < /var/lib/postgresql/data/thingsboard_dump”
Upgrade ThingsBoard:
1
| docker compose run mytbpe upgrade-tb.sh
|
If you still rely on Docker Compose as docker-compose (with a hyphen) execute next command:
docker-compose run mytbpe upgrade-tb.sh
Start ThingsBoard:
1
| docker compose up mytbpe
|
If you still rely on Docker Compose as docker-compose (with a hyphen) execute next command:
docker-compose up mytbpe
Upgrade starting from 3.1.0PE
Please refer to the troubleshooting section in case you are upgrading from 3.0.0 or 3.0.1.
Below is example on how to upgrade from 3.1.0 to 3.1.1
1
| docker compose stop mytbpe
|
If you still rely on Docker Compose as docker-compose (with a hyphen) execute next command:
docker-compose stop mytbpe
- Create a dump of your database:
1
| docker compose exec postgres sh -c "pg_dump -U postgres thingsboard > /var/lib/postgresql/data/thingsboard_dump"
|
If you still rely on Docker Compose as docker-compose (with a hyphen) execute next command:
docker-compose exec postgres sh -c “pg_dump -U postgres thingsboard > /var/lib/postgresql/data/thingsboard_dump”
1
| sudo sh -c "echo '3.1.0' > ~/.mytbpe-data/.upgradeversion"
|
- Then execute the following commands:
1
| docker compose run mytbpe upgrade-tb.sh
|
If you still rely on Docker Compose as docker-compose (with a hyphen) execute next command:
docker-compose run mytbpe upgrade-tb.sh
If you still rely on Docker Compose as docker-compose (with a hyphen) execute next command:
docker-compose up -d
To upgrade ThingsBoard to the latest version those steps should be done for each intermediate version.
Please note that upgrades are not cumulative.
Refer to upgrade instruction to know the right order of upgrades (e.g. if you are upgrading from 3.1.0 to 3.2.1, you need to do that in the following order: 3.1.0 -> 3.1.1 -> 3.2.0 -> 3.2.1, e.g. current version -> next release version -> etc)
In case you need to restore from the backup:
1
| docker compose stop mytbpe
|
If you still rely on Docker Compose as docker-compose (with a hyphen) execute next command:
docker-compose stop mytbpe
1
2
3
| docker compose exec postgres sh -c "psql -U postgres -c 'drop database thingsboard'"
docker compose exec postgres sh -c "psql -U postgres -c 'create database thingsboard'"
docker compose exec postgres sh -c "psql -U postgres thingsboard < /var/lib/postgresql/data/thingsboard_dump"
|
更新最新镜像docker-compose命令:
docker-compose exec postgres sh -c “psql -U postgres -c ‘drop database thingsboard’“
docker-compose exec postgres sh -c “psql -U postgres -c ‘create database thingsboard’“
docker-compose exec postgres sh -c “psql -U postgres thingsboard < /var/lib/postgresql/data/thingsboard_dump”
If you still rely on Docker Compose as docker-compose (with a hyphen) execute next command:
docker-compose up -d
If you need to copy backup to local directory in case restoring it on another server:
1
| docker cp tb-docker_postgres_1:/var/lib/postgresql/data/thingsboard_dump .
|
Note: You should paste the name for your postgres container.
Next steps
-
入门指南 - 快速学习ThingsBoard相关功能。
-
连接设备 - 学习如何根据你的连接方式或解决方案连接设备。
-
可 视 化 - 学习如何配置复杂的ThingsBoard仪表板说明。
-
数据处理 - 学习如何使用ThingsBoard规则引擎。
-
数据分析 - 学习如何使用规则引擎执行基本的分析任务。
-
硬件样品 - 学习如何将各种硬件平台连接到ThingsBoard。
-
高级功能 - 学习高级ThingsBoard功能。
-
开发指南 - 学习ThingsBoard中的贡献和开发。