ThingIO¶

プレーン: データプレーン

目的¶

IoTデータ処理、分析、およびダッシュボードの可視化。ThingIOは、デバイステレメトリの処理、ダッシュボードの構築、ビジュアルウィジェットの作成のためのツールを開発者とオペレーターに提供するプラットフォームサービスです — すべてアカウントに登録されたデバイスにスコープされます。

ThingIO is built on Apache StreamPipes for pipeline execution. It provides account-scoped REST APIs that wrap StreamPipes with FlexGalaxy access control, and a Data API that consumer apps call to query telemetry and pipeline results.

サービス¶

項目	Value
Marketplace	`thingio` (own namespace on TrustMint EKS cluster)
Backend	Python / FastAPI, PostgreSQL
Frontend	React + TypeScript + IBM Carbon Design System
Port	Backend: 8000, Frontend: 80
ECR	`trustmint/thingio-backend`, `trustmint/thingio`

責務¶

Provide REST APIs for scopes, telemetry queries, pipeline management, and consumer app registration
Manage three tiers of data processing pipelines (managed, app, platform)
Accept telemetry ingest from ThingsBoard and analytics results from StreamPipes via Integration API
Auto-provision managed pipelines when devices enroll
Sync scope membership when devices are enrolled/removed in TrustMint

ThingIOと他のサービスとの関係¶

                    ┌─────────────┐
                    │ Applications │
                    │ (WES, CJ)   │
                    └──────┬──────┘
                           │ call ThingIO Data API
                           │ render own dashboards
                           ▼
┌──────────────┐    ┌─────────────┐    ┌──────────────┐
│  TrustMint    │───►│   ThingIO   │◄───│  StreamPipes  │
│  (device      │    │             │    │  (pipeline    │
│   enrollment) │    │ Data API    │    │   execution)  │
└──────────────┘    │ Pipeline API│    └──────────────┘
                    └──────┬──────┘
                           │ reads telemetry
                           ▼
                    ┌─────────────┐
                    │ ThingsBoard  │
                    │ (via Kafka)  │
                    └─────────────┘

TrustMint handles device enrollment → notifies ThingIO for scope sync and managed pipeline provisioning
ThingIOはデータ処理と可視化を処理（API + React SDK）
StreamPipes executes the actual pipelines; ThingIO wraps it with access control
Consumer apps (WES, ClearJanitor) call ThingIO APIs and render their own dashboards — ThingIO does NOT provide dashboard UI for business apps

API Architecture — Two Tiers¶

Management API (via KrakenD at `/thingio/v1/*`)¶

Exposed to consumer apps, the ThingIO frontend, and external developers. Auth: OAuth2 JWT from Keycloak or X-Account-Id header (set by KrakenD).

リソース	Endpoints	説明
スコープ	`GET/POST/PATCH/DELETE /scopes`	Named device filters
ThingIO	`GET /scopes/{id}/things`, `GET /things/{id}`	Devices within a scope (proxied from TrustMint)
Telemetry	`GET /telemetry`, `GET /things/{id}/telemetry`	Time-series queries with scope/key/time filters
パイプラインタイプ	`POST /pipelines`	Pipeline CRUD, templates, start/stop
パイプラインタイプ	`GET /pipelines/{id}`	List available managed + configurable templates
利用者	`GET/POST/PATCH/DELETE /apps`	App registration, permissions, ownership

Integration API (ClusterIP only at `/internal/v1/*`)¶

Never exposed via KrakenD. Auth: internal service token.

Endpoint	利用者	目的
`POST /pipelines`	ThingsBoard REST API / TimescaleDB	Batch telemetry ingest
`POST /sources`	TrustMint	Device enrollment changes → update scope counts
`POST /pipelines/{id}/stop`	TrustMint	Auto-provision Tier 1 pipelines on enrollment

パイプラインタイプ¶

Tier 1: Managed Pipelines (ThingIO provides)¶

Pre-defined, zero configuration. Exist the moment a device enrolls.

例	説明	Input	Output
`device_health_rollup`	Battery trend, connectivity uptime, last-seen	ThingsBoard	`sp.analytics.health`
`telemetry_aggregation`	1min/5min/1hr rollups per device type	ThingsBoard	`sp.analytics.aggregation`
`anomaly_baseline`	Automatic anomaly scoring on numeric keys	ThingsBoard	`sp.analytics.anomaly`

Tier 2: Configurable Pipelines (App self-service)¶

Consumer apps create from templates via POST /pipelines with parameters.

例	Required Params	説明
`threshold_alert`	`key`, `op`, `value`	Alert when telemetry crosses threshold
`geo_fence`	`zone_id`, `device_types`	Alert on zone enter/leave
`rolling_average`	`key`, `window_minutes`	Rolling average over time window

Tier 3: Custom Pipelines (Operator-built)¶

Platform operators build in StreamPipes UI. ThingIO exposes results via the same query API. For complex analytics: ML inference, multi-source correlation, domain-specific pattern detection.

Uniform Consumption¶

All three tiers are queried through the same API. Consumer apps don't care how a pipeline was created:

GET /thingio/v1/pipelines?tier=managed     → Tier 1 results
GET /thingio/v1/pipelines?tier=app         → Tier 2 results
GET /thingio/v1/pipelines?tier=platform    → Tier 3 results
GET /thingio/v1/pipelines/{id}             → Any tier by ID

アカウントスコーピング¶

All ThingIO resources are scoped to the account that creates them.

リソース	スコープ	可視性
スコープ	アカウント	アカウントの登録済みデバイスにバインド
データパイプライン	アカウント	アカウントのデバイスからのテレメトリのみを処理
利用者	アカウント	Registered per account
Telemetry	アカウント	アカウントの登録済みデバイスにバインド

Frontend (ThingIO UI)¶

ThingIO provides a platform-level control plane UI — not a business dashboard. Accessed via Console gateway at /thingio/.

Navigation structure (AdminCenter pattern):

ThingIO
├── Scopes          (header tab)
│   └── Things      (within selected scope)
├── Telemetry       (header tab)
├── Pipelines       (header tab)
│   ├── Managed     (sidebar, Tier 1)
│   ├── App         (sidebar, Tier 2)
│   └── Platform    (sidebar, Tier 3)
└── Consumer Apps   (header tab)

Business apps (WES, ClearJanitor) build their own dashboards by calling ThingIO Data API. ThingIO UI is for platform operators to monitor scopes, pipelines, telemetry records, and consumer app registrations.

Consumer App Integration Pattern¶

Consumer apps call ThingIO APIs to get data and render their own widgets:

WES app
  │
  ├── reads Tier 1 (managed)
  │     GET /thingio/v1/things/{id}/telemetry
  │
  ├── creates Tier 2 (configurable)
  │     POST /thingio/v1/pipelines {template: "threshold_alert", ...}
  │     GET  /thingio/v1/pipelines/{id}
  │
  └── consumes Tier 3 (custom, operator-built)
        GET /thingio/v1/pipelines/{id}

実装¶

項目	技術
Backend	Python 3.12, FastAPI, async SQLAlchemy + asyncpg
データソース	PostgreSQL (in-cluster for dev, RDS for prod)
パイプライン定義	Apache StreamPipes (ThingIO delegates execution)
メッセージバス	Kafka (Strimzi) — telemetry ingest, analytics results
Frontend	React + TypeScript + IBM Carbon Design System
Auth	Keycloak JWT / X-Account-Id header

Deployment¶

Component	Marketplace	アプリケーション	用途
ThingIO	ThingIO	2 (HPA)	`trustmint/thingio-backend`
ThingIO	ThingIO	1-2	`trustmint/thingio`
PostgreSQL	ThingIO	1	PostgreSQL

Network Access (NetworkPolicy)¶

リソース	Access	目的
`api-gateway` ns	Port 8000	Management API via KrakenD
`trustmint` ns	Port 8000	Integration API (scope sync, pipeline provisioning)
ThingsBoard	Port 8000	Integration API (telemetry ingest)
StreamPipes	Port 8000	Integration API (analytics results)
`kafka` ns	Port 8000	Kafka consumer connections

Kafka ACLs (`thingio-consumer`)¶

Topic Pattern	Access	目的
ThingsBoard	React SDK	Telemetry data
`sp.analytics.*`	React SDK	StreamPipes analytics results
`trustmint.device.*`	React SDK	Device enrollment events

依存関係¶

サービス	関係
TrustMint	Device registry, enrollment events, scope sync
ThingsBoard	テレメトリデータソース（Kafka経由）
StreamPipes	パイプライン定義
DotID	API呼び出しの認証、アカウントスコーピング
Kafka	デバイステレメトリと分析のビジュアル監視

利用元¶

利用者	用途
WES	フリートダッシュボード、注文スループット、ゾーン利用率（React SDK経由で埋め込み）
ClearJanitor	清掃カバレッジヒートマップ、ロボットステータスダッシュボード（React SDK経由で埋め込み）
StarGate	プラットフォーム全体のテレメトリ監視のための管理ビュー
ThingIO	Platform operator control plane
利用者	Register, create scopes/pipelines, query telemetry