---
title: Integrate Litmus Edge with Tiger Cloud | Tiger Data Docs
description: Stream industrial device data from Litmus Edge into your service using the PostgreSQL integration connector
---

[Litmus Edge](https://litmus.io/litmus-edge/) is an industrial edge platform that collects data from PLCs, sensors, and other operational technology assets over protocols such as OPC UA, MQTT, and Modbus, then forwards that data to enterprise systems and databases.

This page shows you how to configure the PostgreSQL integration connector in Litmus Edge to stream device data into your Tiger Cloud service, where it is stored as a hypertable for time-series analytics.

In this integration guide, you:

- Create a target hypertable in your Tiger Cloud service.
- Configure the PostgreSQL connector in Litmus Edge to point at your service.
- Subscribe a DeviceHub topic to the connector so device data flows into the hypertable.

## Prerequisites for this integration guide

To follow these steps, you'll need:

- A [Tiger Cloud service](/get-started/quickstart/create-service/index.md).

  These steps use Tiger Cloud, but the same approach applies to a [self-hosted TimescaleDB](/get-started/choose-your-path/install-timescaledb/index.md) instance.

* Your [connection details](/integrate/find-connection-details/index.md).

- A running [Litmus Edge](https://docs.litmus.io/litmusedge) instance that can reach your Tiger Cloud service on port `5432`.
- At least one device configured in Litmus Edge [DeviceHub](https://docs.litmus.io/litmusedge/product-features/devicehub) that is publishing tags you want to stream.

## Prepare your service

Litmus Edge writes every published tag to a fixed schema. Pre-create the table as a hypertable so time-series queries and columnstore policies work out of the box.

1. **Connect to your Tiger Cloud service**

   Use the [Tiger Console](/build/data-management/run-queries-from-tiger-console/index.md), `psql`, or any other SQL editor to connect to your Tiger Cloud service.

2. **Create the target hypertable**

   Litmus Edge writes one row per tag update with the following columns. Create the table directly as a hypertable partitioned on `arrived_at`:

   ```
   CREATE TABLE litmus_data (
       id          bigserial,
       record      uuid              NOT NULL,
       arrived_at  timestamptz       NOT NULL,
       device_id   varchar(64),
       register_id varchar(64),
       tag_name    varchar(64),
       datatype    varchar(32),
       value       varchar,
       success     boolean
   ) WITH (
       timescaledb.hypertable,
       timescaledb.chunk_interval = '7 days',
       timescaledb.segmentby = 'tag_name, device_id, register_id'
   );
   ```

   Litmus Edge’s default schema declares `id` as the primary key, but a hypertable primary key must include the partition column. The statement above omits the primary key so that `arrived_at` alone partitions the data. Leave the `Create Table If Missing` option in Litmus Edge unchecked so it writes into this table instead of trying to create its own.

   If you need row-level uniqueness — for upserts or logical replication, for example — add `PRIMARY KEY (arrived_at, record)`: `record` is already `NOT NULL` and a uuid, and pairing it with the partition column satisfies the hypertable requirement.

   The `chunk_interval` setting controls how much data each hypertable chunk holds. Aim for chunks that fit the most recent working set in memory — a good starting point is an interval that produces chunks roughly 25% of your service’s RAM. For a busy line publishing thousands of tags per second, that may mean hours rather than days; You can change the interval later with [`set_chunk_time_interval()`](/reference/timescaledb/hypertables/set_chunk_time_interval/index.md) — it only affects new chunks.

## Configure the PostgreSQL connector in Litmus Edge

Litmus Edge ships two PostgreSQL integration types: `DB - PostgreSQL` for plaintext connections and `DB - PostgreSQL SSL` for TLS-protected connections. Tiger Cloud requires TLS, so use the SSL variant for Tiger Cloud and either variant for self-hosted TimescaleDB.

1. **Open the Integration pane**

   Log in to Litmus Edge, then select `Integration` from the navigation panel.

2. **Add a PostgreSQL connector**

   Click the add icon, then select `DB - PostgreSQL SSL` from the list of integration connectors.

3. **Configure connection settings**

   Using your [Tiger Cloud service connection details](/integrate/find-connection-details/index.md), fill in the connector fields:

   - `Name`: a label for this connector, for example `tiger-cloud`.
   - `Hostname`: your service hostname.
   - `Port`: `5432`.
   - `SSL Mode`: `require`. Use `verify ca` or `verify full` if you want Litmus Edge to validate the server certificate.
   - `Username`: your service username, typically `tsdbadmin`.
   - `Password`: your service password.
   - `Database`: `tsdb`.
   - `Table`: `litmus_data`.

   Leave `CA Certificate`, `Certificate`, and `Private Key` blank when `SSL Mode` is `require`. For `verify ca` or `verify full`, paste the Tiger Cloud CA certificate into `CA Certificate`.

4. **Tune the write behavior**

   For production workloads that require high throughput, set:

   - `Bulk Insert Count`: number of messages to batch per `INSERT`. A value between `100` and `1000` reduces commit overhead at high message rates.
   - `Commit Timeout`: maximum milliseconds to wait before flushing a partial batch. `1000` is a good starting point — drop to `200`–`500` if you need sub-second freshness.
   - `Persistent Storage`: enable to spool messages to disk if the connection to your service drops, so no data is lost during a brief outage.

   Leave `Create Table If Missing` unchecked — the hypertable you created earlier is the target.

5. **Save the connector**

   Click `OK`. The new connector appears as a tile in the Integration pane with its status indicator.

## Stream device data to your service

A connector by itself does not move data. Subscribe one or more DeviceHub topics to it so tag updates flow into your hypertable.

1. **Open the connector**

   In the Integration pane, click the tile for the connector you just created.

2. **Add a topic subscription**

   Select the `Topics` tab, click the add icon, then choose `add a new subscription`.

3. **Map a DeviceHub tag to the connector**

   Configure the subscription:

   - `Data direction`: `Local to Remote`.
   - `Local data topic`: click the search icon and select the DeviceHub device and tag you want to stream. To stream every tag from a device, use a wildcard suffix.
   - `Remote data topic`: leave the default or enter a label that identifies this stream.
   - `QoS`: `1` for at-least-once delivery.
   - `Enable`: toggle on.

   Click `OK`, then confirm the prompt to restart the connector.

## Verify the integration

To confirm Litmus Edge is writing data to your Tiger Cloud service:

1. **Trigger a tag update in Litmus Edge**

   Generate activity on the subscribed tag — let the device publish, or open the tag in DeviceHub and use `Write Value` to push a test value.

2. **Query the target table**

   From the [Tiger Console](/build/data-management/run-queries-from-tiger-console/index.md) or `psql`, run:

   ```
   SELECT arrived_at, device_id, tag_name, value
   FROM litmus_data
   ORDER BY arrived_at DESC
   LIMIT 10;
   ```

   You see one row per tag update, with `arrived_at` reflecting when Litmus Edge received the value, `device_id` and `tag_name` identifying the source, and `value` holding the payload as a string.

You have successfully integrated Litmus Edge with Tiger Cloud.

## Troubleshooting

- **Connector status shows `disconnected`:** check that the Litmus Edge host can reach your service on port `5432`, and that the `Username`, `Password`, and `Database` match your [connection details](/integrate/find-connection-details/index.md).
- **`relation "litmus_data" does not exist`:** Litmus Edge is writing to the wrong table. Confirm the `Table` field is set to `litmus_data` and `Create Table If Missing` is unchecked.
- **SSL handshake fails:** Tiger Cloud requires TLS — use the `DB - PostgreSQL SSL` connector, not the plain `DB - PostgreSQL` connector. If you selected `verify ca` or `verify full`, make sure the `CA Certificate` field contains the Tiger Cloud CA certificate.
- **No rows appearing after a tag update:** confirm that the topic subscription is `Enabled` and that you restarted the connector after adding it.

For other connectivity and authentication issues, see [Troubleshoot Tiger Cloud integrations](/integrate/troubleshooting/index.md).

## Limitations

- The PostgreSQL connector is outbound only. Litmus Edge writes to your Tiger Cloud service but cannot read from it. To query the hypertable from inside Litmus Edge, use the Litmus SQL node in a Flow — it can read from your service and feed the results back into DeviceHub or another connector.
- Litmus Edge writes the tag payload to a single `varchar` column. Cast `value` to the appropriate type (`(value)::double precision`, `(value)::int`) at query time, or use a continuous aggregate to materialize typed columns.