How-to
Deploying Edge Data Store in Docker on a controller PC
Short answer
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.
On this page
Run AVEVA Edge Data Store as a Docker container on the controller-class edge PC that already runs your application, point its OPC UA adapter at the local OPC UA server over localhost, and define every egress target, buffer and forwarding schedule in the JSON configuration before the installation sees its first network outage. That order matters: the JSON file is the control point for the whole pipeline, and the outage test at the end only proves anything if buffering and egress were defined deliberately. This article gives the architecture, the buffer arithmetic, the deployment order and the pulled-cable test that signs the system off.
One box, one data loop #
The controller-class edge PC runs the control or application program, and that runtime exposes selected variables through its built-in OPC UA server. Edge Data Store runs beside it as a container. Inside the store, OPC UA ingestion is handled by a separate adapter module that communicates with the store over their documented module-to-module interface; the adapter is the piece that connects to the OPC UA server, and in this layout it connects over localhost. The store writes everything it ingests to configurable local storage and forwards it to the egress targets—the AVEVA PI System and/or CONNECT Data Services—on the schedule you set.
Putting the store on the controller PC rather than a separate edge device removes one box, one power supply and one network hop from the data path, and it keeps the local copy of the data where the variables originate. The design decision that follows is simple: ingestion never leaves the box. Tag traffic crosses no plant network to reach a server sitting on the same machine, so the historian's only network dependency is egress. Cut the uplink and collection keeps running into local storage; restore it and forwarding resumes.
Choose the host and the ingestion path #
The host needs a 64-bit operating system with a container runtime, RAM for the store plus the application program, and disk for local storage and buffering. Budget disk as at least twice the worst-case buffer from the next section plus your retention target, and put the buffer on storage that does not share the operating system drive where the layout allows it. If you are specifying the box instead of reusing an existing controller, a fanless industrial mini PC with a 64-bit OS and disk sized this way is the fitting host class. If the edge application is Node-RED rather than a controller runtime, the same host carries it; installing Node-RED natively on a Linux edge computer covers that side of the setup.
For ingestion this article uses the store's built-in OPC UA connectivity, the direct match for controller variables. Built-in Modbus TCP connectivity and push-style entry points for custom programs—Open Message Format (OMF) and a REST API—cover sources with no OPC UA server, and the questions at the end of this article sort out when each fits.
Size the buffer from your own numbers #
Buffering is configured through the buffering configuration parameters in the store's system configuration, and the documentation publishes example configurations you can paste into an empty file and edit. Before you set anything, derive the size from three inputs: tag count, scan rate and the outage duration you are willing to survive.
Worked example, with illustrative inputs and decimal units: 50 tags, one event per second per tag, an 8-hour outage target, 200 bytes per stored event.
- 50 tags × 1 event/s = 50 events/s
- 8 h × 3600 s/h = 28,800 s
- 50 events/s × 28,800 s = 1,440,000 events
- 1,440,000 events × 200 B/event = 288,000,000 B ≈ 288 MB
Decision: provision 0.5 GB of free disk for buffering on this profile, about 1.7 times the expected load, because the bytes-per-event figure is an assumption rather than a measurement. The requirement scales linearly—double the tag count, the scan rate or the outage hours and the buffer doubles—so 100 tags at 1 event/s across 8 hours needs about 576 MB and a 1 GB provision. If your measured 400 B/event replaces the assumed 200, the same 50-tag profile lands at 576 MB expected and a 1 GB provision.
The bytes-per-event input is the one to replace with data: let the store run for 24 hours, read the on-disk size of the streams it created, divide by the event count, and rerun the arithmetic with your number. The counting method here is the same one behind sizing a self-hosted Node-RED, InfluxDB and Grafana historian, so host and disk figures translate between stacks.
Deploy in this order #
- Confirm the host against the budget above: 64-bit operating system, container runtime, and free disk of at least twice the worst-case buffer plus retention.
- Deploy the Edge Data Store container with the vendor's container deployment procedure, and run it so the OPC UA adapter reaches the application's OPC UA server on the loopback interface. No tag traffic should leave the machine.
- Paste the buffering example configuration from the documentation into a file and set it to the outage target you derived—the 8 hours in the example, or your own number.
- Add each egress target in the JSON configuration—the AVEVA PI System and/or CONNECT Data Services—with its endpoint URL and authentication credentials.
- List the OPC UA node IDs the store must ingest from the application's server.
- Set stream prefixes, namespaces and filtering rules so every source lands in an organized place, then set the forwarding schedule and frequency for each destination separately.
- Start the stack and confirm that every configured node produces a stream carrying the prefix and namespace you intended.
- Run the pulled-cable test in the next section before calling the installation production-ready. A historian that has never survived a disconnected uplink is an untested historian.
Sign off with a pulled cable #
The test is deliberately physical. With data changing at the plant, disconnect the uplink for a fixed window—15 minutes proves the mechanism quickly, but it does not exercise your 8-hour sizing target until you run one at that length during commissioning or a maintenance window. Restore the link, let each destination's schedule fire, then compare event counts: events generated during the window against events delivered after it. Equal counts per destination and a clean stream sequence mean the buffering and egress configuration does what the JSON claims. A shortfall means the configuration is wrong: fix the buffer settings or the schedules and retest. Do not widen the forwarding schedule to make a gap look smaller; that hides the fault instead of correcting it.
When both the PI System and CONNECT Data Services are configured, verify each destination independently, because a working target can mask a dead one.
The same layering logic applies one level down. When the SCADA link is the one that breaks, controller-side data-log buffering for SCADA outages is the analogous pattern for keeping controller records alive. And one boundary holds no matter how well the test goes: buffering protects data, not safety. Anything tied to process or personnel safety stays in the certified control path, independent of this store and its uplink.
Questions asked
Does the OPC UA adapter have to run in the same container as the store?
No. The adapter and the store are separate modules that communicate over their documented module-to-module interface, and the vendor publishes procedures for running the adapter inside its own Docker container with different options enabled. Keep the adapter-to-server connection on the loopback interface and confirm both containers resolve that path the same way before you start ingestion.
How does the buffer requirement change at a one-minute scan rate?
It scales linearly with the scan rate, so divide by 60. The worked profile—50 tags at one event per second surviving an 8-hour outage—generates 1,440,000 events, about 288 MB at 200 bytes per event. At one update per minute the same outage generates 24,000 events, roughly 4.8 MB. Measure your own bytes per event from 24 hours of live stream sizes, because value types move that figure.
When should a custom application push to the store instead of using OPC UA?
When there is no OPC UA server to subscribe to—a script, a database job or a legacy program producing readings on its own. The store then accepts data through the Open Message Format (OMF) or the REST API, both designed for applications that submit data directly. Everything downstream works the same: local buffering, egress schedules and stream organization, so the pulled-cable test does not change either.
Does the store keep collecting while the uplink is down?
Yes. Collection and local storage run independently of egress, so ingested data keeps accumulating in the configured local storage while the network is unavailable. When connectivity returns, each destination's forwarding schedule resumes and the buffered window is delivered to the PI System or to CONNECT Data Services. Confirm that behavior on your own deployment with the pulled-cable test rather than assuming it.