DeviceChain
English
Download
Platform · Performance

Measured on a real cluster, with the conditions beside every number.

Every figure here comes from a measurement published in the DeviceChain docs. Each one is shown with the cluster it ran on, the load that produced it and a link to the published row. The results describe those workloads and clusters. They are not a capacity guarantee.

Every run here used the replicated high-availability configuration. Each used dcctl install --ha: the message broker is a 3-node cluster with every stream and key-value bucket replicated across it, the relational database runs as three instances with synchronous replication, the event store is replicated to three instances (asynchronously when no standby is available), and event-management, which stores every event, runs as two pods (the other services run one replica each). These are production-shaped numbers on a replicated cluster, not a single-node benchmark. HA, in the docs →
Mixed load

HTTP, MQTT and detection rules together.

The same mix ran in both measurements below: devices posting over HTTP at 2,500 events/s, 1,500 MQTT sessions over TLS at one event per second each, and 2,000 events/s going through detection rules, plus command traffic. Each event carried one reading.

The v1.1.0 build

GKE · 3 services + 3 database + 3 broker nodes · replicated HA
6,211 events/sstored in the steady windowMixed HTTP, MQTT over TLS and detection rules; a 15-minute steady window after a 4-minute warm-up; shape B below. Replicated HA install.
17.6 msstoring an event, medianThe same steady window and shape. Replicated HA install.
107.4 msstoring an event, 99th percentileThe same steady window and shape. Replicated HA install.
17.9 msMQTT publish acknowledged, 99th percentileThe same steady window and shape. Replicated HA install.
2.06 CPU-splatform CPU per 1,000 events storedThe platform's own services over the same 15-minute steady window; shape B below. Replicated HA install.

A development build shortly before the v1.1.0 release, and one run. The test tenants' ingest ceiling was raised for the test. Source: the measured-throughput table → CPU per event: the v1.1.0 release notes →

The v1.0.0 release candidate, for an hour

GKE · 3 services + 3 database nodes · replicated HA
~6,000 events/ssustained for an hourOne 60-minute run of the mixed load, on shape A below. Replicated HA install.
~1 sdetection lag, medianSteady state, in the same run. Replicated HA install.
21 msMQTT publish acknowledged, 99th percentileSteady state, in the same run. Replicated HA install.
96 msrule action dispatched, 99th percentileSteady state, in the same run. Replicated HA install.
109–123 msstoring an event, 99th percentileSteady state, in the same run; the range the run reported. Replicated HA install.

The release candidate that became v1.0.0. The hour included one deliberate 60-second stop of the event-sources service; the latency and lag figures are from outside that window, and the traffic during it is in none of them; the source row has the full account. The busiest service nodes ran at 85 to 92% CPU, so this shape is near the top of what these three service nodes carry at this mix. MQTT acknowledgement was at its default: the broker's optional stricter acknowledgement mode was off, so these acknowledgement times are not a promise about what the platform had already stored. The admin ingress was plain HTTP (dcctl bootstrap --no-tls) while MQTT stayed on TLS, and the test tenants' ingest ceiling was raised for the test. Source: the measured-throughput table →

MQTT alone

Where MQTT over TLS reached its acknowledgement bound.

MQTT over TLS at QoS 1, one event per session per second, each step on its own fresh tenant after a 3-minute warm-up and measured over an 11-minute steady window, on shape B below. The 99th-percentile acknowledgement time stayed under a 50 ms bound up to the highest step shown below and passed it at 6,000 events/s (60.1 ms over the run).

GKE · 3 services + 3 database + 3 broker nodes · replicated HA
5,250 events/sMQTT over TLS, highest step within the boundQoS 1, one event per session per second; each step on a fresh tenant; 11-minute steady window; shape B. Replicated HA install.
27.6 msacknowledgement, 99th percentile, at that stepThe same step; the bound it is judged against is in the text above. Replicated HA install.

At that point one broker server was the busiest resource, while the services and database nodes had room to spare. Each figure is one run, taken after the broker's stream leaders were rebalanced. Source: the measured-throughput table →

Hardware

The two cluster shapes.

Both ran on Google Kubernetes Engine in us-east4-b, on a replicated (--ha) install, with the load generator on its own node. Placement was left to the Kubernetes scheduler and the broker; the MQTT steps ran after the broker's stream leaders were rebalanced. MQTT acknowledgement was at its default in both: the broker's optional stricter acknowledgement mode was off.

ShapeNodesInstall and disks
A: v1.0.0 release candidate 3 × t2d-standard-4 service nodes, 3 × n2d-standard-4 database nodes (databases only), 1 × n2d-standard-4 load-generator node dcctl install --ha, then dcctl bootstrap --no-tls; standard persistent boot disks; the event-store volume expanded to 64 GiB before any traffic
B: v1.1.0 development build The same three pools, plus a broker pool of 3 × t2d-standard-4 private nodes (tainted for the broker); the broker is the upstream NATS server, unmodified dcctl install --ha, then dcctl bootstrap --no-tls --no-escrow; 100 GB standard persistent boot disks; premium-rwo as the default storage class; event envelopes off

Shape B ran with Go profiling enabled and pg_stat_statements on both databases.

Method

What the numbers mean.

These results describe that workload and cluster, not a capacity guarantee. Measure your own load on your own cluster before sizing for it.

Reproduce it

Run your own measurement.

The repository links below are pinned to the v1.1.0 tag. They are the tools the measurements used, not a one-command replay: the scripts' default loads and the cluster configuration's default machine types differ from the shapes above, so set the rates and node pools yourself.

  1. Create a cluster. An OpenTofu configuration with machine-type notes and quota advice is in deploy/gke. It bills until you destroy it.
  2. Install. dcctl install --ha and dcctl bootstrap; see the bootstrap guide.
  3. Generate the load. Build the load generators from backend/sims/dc-simulator/cmd/loadtest* at the tag (they are not in the release archives), then run hack/loadtest-rc-run.sh.
  4. Compare per-event costs on a workstation. hack/perf-ab.sh and hack/perf-ab-compare.sh run on a local kind cluster. Message, byte and row counts at the same offered rate carry over to other machines; CPU there is a ratio between two runs on the same machine.

Earlier measurements, in the docs →