IMD SolutionComputing LibraryShop main store

Explainer

Can plant historian software run in Docker containers

Edge computing and IIoT Published 7 min read

Short answer

The processes will start, but historian services hold retained state and are not documented to communicate statelessly, so a started container proves nothing about collection, calculations, events, or queries surviving replacement. Keep the working deployment in production and evaluate containers only in an isolated test, with a volume mapped for every path that holds data or configuration, passing a counted query across a restart, a recreate, and a host move.

On this page
  1. Can plant historian software run in Docker containers?
  2. What does a running container actually prove?
  3. Why does stateless communication matter for historian services?
  4. What happens to historian data when a container is recreated?
  5. How do you evaluate containers without risking production?
  6. How do you prove history survived the container change?
  7. Do multiple container replicas help a historian?
  8. When does production stay on the existing deployment?
  9. Questions asked

Usually the processes will start — and that is the trap. A plant historian's services hold retained state and are not documented to communicate statelessly, so a container that starts proves only that a process launched, not that collection, calculations, events, or historical queries survive replacement. Keep the working deployment in production and treat containers as an isolated engineering evaluation: map a volume to every path that holds data or configuration, then prove the history with counted queries across a restart, a container recreate, and a move to another host. Anything less is a screen that opened, not a historian that survived.

Can plant historian software run in Docker containers? #

As an unverified evaluation, yes; as a supported production deployment, not until your historian vendor documents it, because these services keep retained state and are not documented to communicate statelessly.

A historian is a database-storage service for long-term monitoring and test data, typically logging values over OPC UA, and its whole value is the archive it accumulates plus the processing configured against that archive. When a vendor states that containers are untested, take that at face value: it is neither a technical prohibition nor a validated deployment recipe. For software whose vendor does document a container deployment, the work is configuration — one worked example is Deploying Edge Data Store in Docker on a controller PC. Container platforms manage stateless and stateful workloads alike, so the platform is never the deciding factor; the application's own behavior is.

What does a running container actually prove? #

A running container proves only that the process launched — not that the service can find its configuration, reach its peers, authenticate, restore its context, or read the archive a query asks for.

Startup and readiness are different conditions. A service can be up and serving nothing while its configuration path is empty or a peer endpoint is unreachable, and the symptom arrives later as an empty trend or a calculation that never fires. That is why the evaluation below counts samples instead of trusting container state, and why a generic connection failure should not be reclassified as a container defect until endpoint reachability and the application connection are tested separately. Record the actual messages and timestamps from the installed services as you go.

Why does stateless communication matter for historian services? #

Stateless communication means a request is answered without retained conversational context; historian services are not documented to work that way, so replacing one can break more than the current request.

A gateway or API forwarder that keeps no persistent data is the classic stateless case. A historian is the opposite: established context and retained service state are part of the contract between its components. Keep two distinctions straight. First, communication state is not stored data — persisting files does not restore a service relationship, and reconnecting services does not prove the data or configuration are still there. Second, statefulness is per component: at least one historian vendor documents its connector driver as stateless, holding no source connections and no data caches, which is exactly why a driver moves more freely than the archive behind it. Identify the dependencies of each installed component from its documentation, not from its name.

What happens to historian data when a container is recreated? #

Recreating a container discards its writable layer, so anything not mapped to a volume is gone — which is why every path holding data or configuration must be mapped before the first recreate test.

The documented behavior to design against: volumes are persistent data stores created and managed by Docker, and a recreated container starts with a fresh writable layer, so only volume-mapped paths carry over. Volume drivers can also place the store outside the host machine, which is what makes a host-move test meaningful rather than automatic.

Replacement event Writable layer Volume-mapped store
Container restart Kept Kept
Container recreate Discarded Kept
Move to another host Left on the old host Kept only when the volume lives outside the host or moves with it

The decision follows from the table: map a volume to every path that holds data, configuration, or credentials. No historian component's store belongs in the writable layer.

How do you evaluate containers without risking production? #

On a segregated host, against a controlled data source, one boundary at a time — with the working deployment untouched in production until the evaluation passes a restart, a recreate, and a host move.

Give the evaluation its own machine — a spare fanless mini PC on an isolated switch — so a misconfigured collector cannot write to live controllers or double-count production records. Then work the sequence:

  1. Inventory the installation: software release, component list, service identities, dependencies, configuration paths, data paths, licensing requirements.
  2. Confirm the environment: required operating system, installer behavior, runtime dependencies, and service-management expectations against what the container provides.
  3. Map the relationships: which service connects to which endpoint, how each authenticates, and what each needs after an interruption.
  4. Classify retained state: data, configuration, credentials — map a volume to each and verify access permissions under the service identity.
  5. Baseline the working deployment: recorded timestamps, query results, and the outputs of the configured calculations and events.
  6. Change one boundary at a time, keeping a reproducible path back to that baseline.

How do you prove history survived the container change? #

By counting samples across the replacement: a tag logged every 5 seconds accumulates 720 values per hour, so a query after the recreate must return those 720 plus the new ones — anything less is proven loss.

Illustrative test inputs: one watched tag on a 5-second scan, a 200-tag collection group, a 61-minute window.

  • Samples per tag per hour: 3,600 s ÷ 5 s = 720.
  • Group rate: 200 tags × 720 = 144,000 values per hour, and 144,000 × 24 = 3,456,000 values per day.
  • Expected in the 61-minute window: 61 × 60 = 3,660 s; 3,660 s ÷ 5 s = 732 samples per tag.

Collect for 61 minutes, then recreate the container with the store left unmapped. The query over the window returns only what was logged after the recreate — if 12 samples arrived in the first minute back, you see 12 of 732, and (732 − 12) ÷ 732 = 98.4 percent of the hour is gone because it lived in the discarded writable layer. Map the store to a volume, repeat the hour, recreate at the same point: the same query must now return 732, the 720 old samples plus the 12 new ones. Counts scale linearly with scan rate and tag count — halve the scan interval and every number doubles — but the test itself does not change.

Counts prove storage, not processing, so also confirm that a configured calculation reproduces its output and a configured event fires across the recreate. And if the count is right while the screen is empty, the fault is in the display binding or the client query, not the container — the same split used in historian trend empty PLC tag collection troubleshooting.

Do multiple container replicas help a historian? #

No — run one instance of each service: concurrent instances compete for shared state and duplicate collection unless the deployment model explicitly supports it, and an orchestration platform's ability to scale is not the application's.

Running two collectors side by side is a migration pattern with a documented walkthrough, not something to improvise in a container test; see running two Plant SCADA Historian connectors during migration. Also remember that a startup dependency is not a readiness check: a process can start before its data path exists, and only the counted query tells you the difference.

When does production stay on the existing deployment? #

Until the evaluation passes all three replacement events with matching query counts, production stays on the documented deployment — and if the vendor still lists containers as untested, that remains the answer for that release.

The decisions by case:

  • Production collection today: keep the working deployment. It preserves the established environment and communication paths while container compatibility is unresolved.
  • Repeatable test or lab environment: containers are the right tool, with volumes mapped and collection pointed at a controlled source.
  • Recovery planning: the host-move case decides whether your volume placement must live outside the host machine; a deployment that passes restart and recreate but not the move is not portable.

A container-based production design earns its place only after installation, dependencies, persistence, and recovery are all reproduced reliably — which is exactly what the counted-query evaluation above demonstrates.

Questions asked

Does mounting a volume make a historian service stateless?

No. Persistence and stateless communication are separate properties: a volume keeps files across replacement, while stateless communication means no retained conversational context between requests. One practical note from the documentation: volumes work on both Linux and Windows containers, so the host operating system is not what blocks the evaluation — the service's own retained context is.

How long should the isolated evaluation run before we trust it?

Plan one week of continuous collection, and inside that week force all three replacement events: a restart, a recreate, and a move to another host. The week is not arbitrary — scheduled weekly jobs such as rollups, aggregates, and archive rotation must fire across a replacement at least once before the deployment earns trust.

If the container restarts automatically after a crash, is that enough recovery?

No. A restart is the weakest of the three tests because it keeps the writable layer, so it cannot expose the loss a recreate causes. An automatic restart policy is worth having, but it only proves the process comes back; the counted query after a recreate is what proves the history comes back.

Can we copy the production historian's files into the test container?

Yes for read-only query testing, no for collection. A copied archive answers queries fine, but if its collector still points at the live sources you have built a second writer that double-counts production data. Repoint collection at a test or simulated source before the container starts, and keep the copy on a volume so recreating the test container does not discard it.

Keep reading

  • How-to

    Run Python and Node-RED beside PLC code on an edge PC

    Keep the IEC 61131-3 program in the controller runtime and run Python and Node-RED as separate Docker containers on the same edge PC. Exchange data over one MQTT interface with a fixed publish period, and declare data stale after three missed periods. One container per workload, and nothing from Python or Node-RED inside the control project.

    Edge computing and IIoT

  • How-to

    Deploying Edge Data Store in Docker on a controller PC

    Run Edge Data Store as a Docker container on the controller-class edge PC and let its OPC UA adapter ingest the local server over localhost. Define egress targets, buffering and forwarding schedules in the JSON configuration, size the buffer from tag count, scan rate and outage target—50 tags at 1 event/s across an 8-hour outage is about 288 MB—and sign off only after a live pulled-cable test.

    Edge computing and IIoT

  • Comparison

    Evaluating Ignition historian with TimescaleDB for your plant

    The Gold Technology Provider announcement is a reason to test TimescaleDB behind Ignition, not proof it replaces your historian. No footprint, compression or performance number is documented for this pairing. Adopt it only after a replay test on your exact Ignition 8.3 build measures growth, ingestion continuity, query response and backup/restore against your current store.

    Edge computing and IIoT