Deploy AI Model Files to Multiple Edge Devices

Getting Started#

Basic Concept#

When running AI models in an edge environment, model files trained or prepared on a central server must be deployed to multiple edge devices.

For example, you can deploy a new image analysis model to factory camera devices or replace models on edge servers installed in stores and logistics centers with a new version.

The deployment target may include more than a single model file. Inference settings, class information, runtime configuration files, and other files may need to be deployed to the same device together with the model.

If files are copied directly to multiple devices, you must check each device individually to determine which model version was applied and whether all required configuration files were delivered.

With a Flow, you can configure prepare model files → select deployment targets → transfer to multiple edge devices in parallel → verify results by device as a single workflow.

This recipe configures a process for deploying centrally prepared AI models and configuration files to multiple edge devices and checking file-processing results and success for each device.

Deployment Configuration#

Model deployment to edge devices can be configured not only to deliver the same model to every device, but also to deliver different models and configurations based on device type or installation location.

For example, the same model can be deployed to multiple factories using identical camera devices, while separate models and configuration files can be delivered to devices in different environments.

As the number of devices increases, it becomes more important to configure deployment criteria and target devices together rather than managing files individually for each device.

File Structure#

When deploying an AI model, configuration and supporting files required for inference may be used together with the actual model file.

For example, a model package can use the following file structure.

Each file serves a different purpose on the edge device.

By organizing the model package as a single deployment unit, you can deliver the complete set of files required by the actual device instead of transferring multiple files separately.

IT Engineer#

Device Connection#

First, connect the system containing the prepared AI model as the Source and configure each edge device that will run the model as a Target.

Edge devices may include not only devices on the same network, but also servers installed at branches, factories, or remote environments.

Specify where the model files will be stored on each Target.

If every device uses the same directory structure, a common path can be applied. If operating environments differ, storage locations can be configured separately for each device.

This clearly defines which model will be deployed to which device.

Target Segmentation#

If not all edge devices perform the same role, devices can be segmented for deployment based on their role or installation environment.

For example, if inspection devices inside a factory and analysis devices at external stores use different models, separate deployment targets can be configured for each.

In this case, instead of deploying one model to every device at once, the target scope can be divided by device group and model version.

With this configuration, when deploying a new model, you can select only the actual deployment targets and deliver it to the required devices.

Run Deployment#

After configuring the model files and target devices, deploy the files to multiple Targets in parallel.

With parallel deployment, deployment can proceed to multiple edge devices simultaneously instead of waiting for the file transfer to one device to finish before moving to the next.

Because deployment to each device proceeds independently, the connection status of a specific device can be checked separately from other targets.

For example, if model deployment has completed on some devices but a specific device requires an additional connection check, the result for that Target can be reviewed separately.

Execution Conditions#

Model deployment can run as soon as new files are ready, or it can be configured to run at a specified time after an operator reviews the model.

In particular, when replacing models running on multiple edge devices, both the deployment time and the completion status of previous operations can be considered.

This reduces the chance of deployment starting before model files are ready or before a previous operation has completed.

Deployment Flow#

Model deployment to edge devices does not have to end with a simple file transfer. It can also include verification that all files required by the actual device were applied.

If necessary, separate verification or operational checks can be connected after model deployment completes.

For example, if model files are successfully applied to all target devices, the next operation can run. If a specific device requires additional verification, the workflow can be configured to check that device's status.

Verify Results#

When the deployment runs, check the overall deployment status and processing results for each device in Runs.

Even when the same model is deployed to multiple edge devices, each Target result can be viewed separately to determine which devices received the files successfully.

The following items can be checked in the execution results.

This allows file deployment results for multiple devices to be compared on a single execution screen instead of checking each device individually.

Handle Failures#

If model files are not applied successfully to some edge devices, review the Run details to identify the affected devices and file-processing status.

For example, if a remote device loses its connection or cannot store files at the specified model path, check the Target connection, path, and access permissions.

When a failure occurs, check the following items together.

After resolving the issue, you can rerun the required operations for Targets that need additional verification instead of reconfiguring deployment for every device.

After rerunning, use the new Run to verify that the model and configuration files were successfully applied to the edge device.

This process creates an AI model deployment flow covering prepare model files → configure deployment targets → segment device groups → parallel deployment → apply files by device → verify results → handle failed targets.

By deploying model and configuration files to multiple edge devices and managing success by device, the process of applying a new model to a production environment can be operated as a single managed Flow rather than as separate device-level tasks.

Developer#

Deploy model and configuration files to multiple edge devices and verify success for each device

After registering the source and target edge devices as Devices, create a transfer for each device, wait for them together, and aggregate the results. Prepare the following before starting.

Python and Node.js reuse the minimal api() helper for direct REST calls and the status constants (STATUS_COMPLETE and TERMINAL) from the API Call Recipe. Java and C# use the bundled InnorixClient (including constants) and Json helper (J for C#). Replace device identifiers and paths with actual values.

Deploy a Model to Multiple Edge Devices#

Create a transfer for each target and collect the monitorId values first, then wait for all transfers. Enable checkIntegrity to verify that the delivered model files match the originals. Devices where transfer creation itself fails (for example, because they are offline) are collected separately from failures that occur during transfer.

import time


def deploy_model(source, source_path, targets, target_path, action="overwrite"):
    monitors, start_failed = {}, []
    for device in targets:
        try:
            transfer = api("POST", "/api/transfers/manual", {
                "sourceDevice": source,
                "targetDevice": device,
                "targetPath": target_path,
                "sourcePaths": [source_path],
                "sendAllFolder": True,
                "checkIntegrity": True,   # verify model file integrity after transfer
                "transferOptions": {"target-action": action},
            })
            monitors[device] = transfer["monitorId"]
        except Exception:
            start_failed.append(device)   # device whose transfer creation itself failed (e.g. offline)

    results = {}
    for device, monitor_id in monitors.items():
        detail = wait_transfer(monitor_id)
        results[device] = detail.get("status") == STATUS_COMPLETE
    # report devices that never started separately from in-transfer failures
    return {"results": results, "start_failed": start_failed}


def wait_transfer(monitor_id, timeout=14400, interval=5):
    deadline = time.time() + timeout
    while time.time() < deadline:
        detail = api("GET", f"/api/transfers/{monitor_id}") or {}
        if detail.get("status") in TERMINAL:
            return detail
        time.sleep(interval)
    raise TimeoutError(monitor_id)


out = deploy_model("model-src", "/registry/model/v3",
                   ["edge-01", "edge-02", "edge-03"], "/opt/models")
results, start_failed = out["results"], out["start_failed"]
ok = [d for d, c in results.items() if c]
print(f"ok {len(ok)} / started {len(results)} / start-failed {len(start_failed)}")
for device, complete in results.items():
    if not complete:
        print("  transfer failed:", device)
for device in start_failed:
    print("  start failed (check connection):", device)

// returns: results (success after the transfer started) + startFailed (devices whose transfer creation failed)
static Map<String, Object> deployModel(InnorixClient client, String source, String sourcePath,
        List<String> targets, String targetPath, String action) throws InterruptedException {
    Map<String, String> monitors = new LinkedHashMap<>();
    List<String> startFailed = new ArrayList<>();
    for (String device : targets) {
        try {
            Map<String, Object> transfer = client.apiObj("POST", "/api/transfers/manual", Json.newObj(
                    "sourceDevice", source,
                    "targetDevice", device,
                    "targetPath", targetPath,
                    "sourcePaths", List.of(sourcePath),
                    "sendAllFolder", true,
                    "checkIntegrity", true,   // verify model file integrity after transfer
                    "transferOptions", Json.newObj("target-action", action)), null);
            monitors.put(device, Json.str(transfer, "monitorId"));
        } catch (Exception ex) {
            startFailed.add(device);   // transfer creation failed (e.g. offline)
        }
    }

    Map<String, Boolean> results = new LinkedHashMap<>();
    for (Map.Entry<String, String> e : monitors.entrySet()) {
        Map<String, Object> detail = waitTransfer(client, e.getValue(), 14400, 5);
        Integer status = Json.intOrNull(detail, "status");
        results.put(e.getKey(), status != null && status == InnorixClient.STATUS_COMPLETE);
    }
    return Json.newObj("results", results, "startFailed", startFailed);
}

static Map<String, Object> waitTransfer(InnorixClient client, String monitorId,
        long timeoutSec, long intervalSec) throws InterruptedException {
    long deadline = System.currentTimeMillis() + timeoutSec * 1000;
    while (System.currentTimeMillis() < deadline) {
        Map<String, Object> detail = client.apiObj("GET", "/api/transfers/" + monitorId, null, null);
        Integer status = Json.intOrNull(detail, "status");
        if (status != null && InnorixClient.TERMINAL.contains(status))
            return detail;
        Thread.sleep(intervalSec * 1000);
    }
    throw new RuntimeException("timeout: " + monitorId);
}

async function deployModel(source, sourcePath, targets, targetPath, action = "overwrite") {
  const monitors = {};
  const startFailed = [];
  for (const device of targets) {
    try {
      const transfer = await api("POST", "/api/transfers/manual", {
        sourceDevice: source,
        targetDevice: device,
        targetPath,
        sourcePaths: [sourcePath],
        sendAllFolder: true,
        checkIntegrity: true,   // verify model file integrity after transfer
        transferOptions: { "target-action": action },
      });
      monitors[device] = transfer.monitorId;
    } catch {
      startFailed.push(device);   // transfer creation failed (e.g. offline)
    }
  }

  const results = {};
  for (const [device, monitorId] of Object.entries(monitors)) {
    const detail = await waitTransfer(monitorId);
    results[device] = detail.status === STATUS_COMPLETE;
  }
  return { results, startFailed };
}

async function waitTransfer(monitorId, { timeout = 14400, interval = 5 } = {}) {
  const deadline = Date.now() + timeout * 1000;
  while (Date.now() < deadline) {
    const detail = (await api("GET", `/api/transfers/${monitorId}`)) || {};
    if (TERMINAL.has(detail.status)) return detail;
    await new Promise((r) => setTimeout(r, interval * 1000));
  }
  throw new Error(`timeout: ${monitorId}`);
}

const { results, startFailed } = await deployModel("model-src", "/registry/model/v3",
                                  ["edge-01", "edge-02", "edge-03"], "/opt/models");
const ok = Object.values(results).filter(Boolean).length;
console.log(`ok ${ok} / started ${Object.keys(results).length} / start-failed ${startFailed.length}`);
for (const [device, complete] of Object.entries(results))
  if (!complete) console.log("  transfer failed:", device);
for (const device of startFailed) console.log("  start failed (check connection):", device);

// returns: results (success after the transfer started) + startFailed (devices whose transfer creation failed)
static async Task<(Dictionary<string, bool> results, List<string> startFailed)> DeployModelAsync(
    InnorixClient client, string source, string sourcePath, IEnumerable<string> targets,
    string targetPath, string action = "overwrite")
{
    var monitors = new Dictionary<string, string>();
    var startFailed = new List<string>();
    foreach (string device in targets)
    {
        try
        {
            var transfer = await client.ApiObjAsync("POST", "/api/transfers/manual", new JsonObject
            {
                ["sourceDevice"] = source,
                ["targetDevice"] = device,
                ["targetPath"] = targetPath,
                ["sourcePaths"] = J.ArrOfStrings(new[] { sourcePath }),
                ["sendAllFolder"] = true,
                ["checkIntegrity"] = true,   // verify model file integrity after transfer
                ["transferOptions"] = new JsonObject { ["target-action"] = action },
            });
            monitors[device] = J.Str(transfer, "monitorId");
        }
        catch
        {
            startFailed.Add(device);   // transfer creation failed (e.g. offline)
        }
    }

    var results = new Dictionary<string, bool>();
    foreach (var kv in monitors)
    {
        JsonObject detail = await WaitTransferAsync(client, kv.Value);
        int? status = J.IntOrNull(detail, "status");
        results[kv.Key] = status != null && status == InnorixClient.StatusComplete;
    }
    return (results, startFailed);
}

static async Task<JsonObject> WaitTransferAsync(InnorixClient client, string monitorId,
    int timeoutSec = 14400, int intervalSec = 5)
{
    DateTime deadline = DateTime.UtcNow.AddSeconds(timeoutSec);
    while (DateTime.UtcNow < deadline)
    {
        JsonObject detail = await client.ApiObjAsync("GET", 
quot;/api/transfers/{monitorId}", null, null);
        int? status = J.IntOrNull(detail, "status");
        if (status != null && InnorixClient.Terminal.Contains(status.Value))
            return detail;
        await Task.Delay(intervalSec * 1000);
    }
    throw new TimeoutException(monitorId);
}

Integrity verification For transfers targeting servers or devices, checkIntegrity: true can compare checksums of the source and destination files. See the Integrity Verification Recipe for detailed verification methods.

Identify offline devices Devices where the transfer could not start may have an empty failed-file list. In this case, check the device connection status before retrying, then deploy again after the connection is restored.

For failed devices, use retry_failed from the Pause and Resume Recipe to retransmit only the failed files.

Implementation Result#

With this recipe, you can deploy a model to multiple edge devices using the following flow.

You can deploy model and configuration files to multiple edge devices, verify integrity, aggregate success by device, and redeploy only failed devices.