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.
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 →
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 HAA 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
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 →
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 HAAt 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 →
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.
| Shape | Nodes | Install 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.
What the numbers mean.
- An event is one reading from one device. In the v1.1.0 mixed run, each kind of load had its own tenant.
- Sustained means held over the stated window. A figure from a run of a few minutes is a short-run figure, and none is shown here.
- Percentiles are the 99th unless a card says median.
- CPU per 1,000 events is the CPU the platform's own services used in the steady window, per 1,000 events stored in it. The databases are counted separately in the release notes.
- Tenants: a load spread across many tenants sees smaller write batches than a single-tenant one.
- Not measured here: a cluster of another shape, other load mixes, or anything outside the mixes above.
These results describe that workload and cluster, not a capacity guarantee. Measure your own load on your own cluster before sizing for 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.
- Create a cluster. An OpenTofu configuration with machine-type notes and quota advice is in deploy/gke. It bills until you destroy it.
- Install.
dcctl install --haanddcctl bootstrap; see the bootstrap guide. - 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.
- 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.