Skip to Content
Applied SciencesApplied Sciences
  • Article
  • Open Access

3 September 2026

25 Pages

Container Orchestration with Kubernetes for ROS-Based Robot Software

,
,
,
,
and
1
Institute for Systems and Computer Engineering, Technology and Science, Campus of the Faculty of Engineering, University of Porto, Rua Dr. Roberto Frias, 4200-465 Porto, Portugal
2
Faculty of Engineering, University of Porto, Rua Dr. Roberto Frias, s/n, 4200-465 Porto, Portugal
*
Author to whom correspondence should be addressed.
This article belongs to the Section Computing and Artificial Intelligence

Abstract

Robot Operating System (ROS) applications are growing increasingly complex and distributed, incorporating multi-node architectures, real-time communication, and compute offloading to cloud or edge resources. Despite advances in containerization, large-scale robotics deployments often rely on ad hoc provisioning, updating, and scalability strategies. This paper’s key contribution is a module extension for an existing ROS-focused container framework that leverages Kubernetes’ capabilities—controlled rolling updates, ROS-adapted readiness checks, distributed workload management, and embedded observability—to bridge cloud-native practices with robotics development. The result is a unified tool that streamlines the entire ROS DevOps cycle. Experimental validation demonstrates stable operation with minimal message loss across diverse ROS communication patterns, including tests on an industrial mobile manipulator system. By simplifying orchestration and monitoring, this approach enables roboticists to concentrate on application logic rather than deployment and networking complexities.

1. Introduction

Robotic applications are increasingly deployed in scenarios demanding reliability, scalability, and near real-time responsiveness—from autonomous vehicles to warehouse robots and industrial mobile manipulators [1,2,3,4]. Traditionally, robot software was monolithic and hosted on embedded hardware. However, cloud robotics now distributes computation by offloading intensive tasks (e.g., computer vision or AI inference) to edge or cloud servers to overcome onboard resource limitations [5].
In parallel, the robotics community has adopted containerization to ensure reproducible environments and consistent deployments. Tools like Docker (https://www.docker.com/), Podman (https://podman.io/), and official ROS images [6] have streamlined packaging and dependency management. However, container creation and orchestration across robots remains largely manual, highlighting the gap between simple containerization and true Continuous Delivery (CD), which automates application packaging and release to execution environments. While CD is well-established in web services, its adoption in robotics remains challenging due to hardware-in-the-loop testing requirements and Cyber-Physical Systems (CPSs) constraints [7].
In a typical DevOps pipeline, passing tests and approved merge requests trigger automated image building and archiving in a registry [8]. Building on Continuous Integration (CI), continuous deployment automatically deploys software artifacts to cloud instances, edge servers, or local systems [9]. These pipelines rely on consistent environments and well-defined interfaces, in which containerization encapsulates application code, libraries, and configurations for real-time operation. Thus, DevOps and containerization have become interdependent pillars of modern robotic software development [10].
Despite the recognized advantages of DevOps, roboticists still face several persistent challenges. ROS 1’s reliance on a central master makes it highly sensitive to the dynamic IP addresses and transient networks typical of containerized environments. This network fragility is compounded by the close coupling of software with physical hardware. As Cyber-Physical Systems (CPSs), robots must sense and actuate in real physical environments, meaning that nodes managing hardware or real-time streams require precise staging of updates; even brief interruptions can stall robots mid-task or trigger costly safety procedures. Furthermore, limited on-robot resource budgets and strict latency requirements often necessitate offloading compute-intensive tasks—such as 3D perception—to edge or cloud infrastructure. This complexity in verifying correct real-world behavior and meeting real-time deadlines becomes a significant obstacle to the rapid, frequent releases that DevOps promotes. Moreover, when these systems scale to include multiple computers or entire fleets, they add a distributed dimension to the code and data flows. Nevertheless, recent studies [7] show that the robotics industry is increasingly adopting DevOps principles, driven by the need for faster prototyping, continuous testing across both simulation and hardware environments, and more robust post-deployment monitoring.
Recent works show that container orchestration platforms (e.g., Kubernetes (https://kubernetes.io/), Docker Swarm (https://docs.docker.com/engine/swarm/—accessed on 7 July 2026) can assist with dynamic scaling, automated restarts, and rolling updates [11], despite existing solutions for robotics being incohesive. Addressing these gaps, we integrate Kubernetes into a container-based framework, Rigel [10], enabling readiness-gated rolling updates, dedicated readiness checks for ROS, and a built-in observability layer.
In detail, Rigel is a framework that automates builds and CI/CD testing for ROS applications [10]. The present work extends Rigel with a Kubernetes-based orchestration module, completing the toolchain from code commit to cloud deployment and observability. This integration closes the DevOps loop for robotics by enabling a single, unified tool to streamline the entire development lifecycle.
The proposed orchestration module targets both ROS 1 and ROS 2 deployments. In ROS 2, readiness and health checks are driven by Data Distribution Service (DDS)-based discovery and endpoint matching (publisher/subscriber and service/action endpoints). In ROS 1, the same orchestration flow is preserved with the addition of ROS master registration and topic availability checks layered on top. This dual-path design keeps rolling-update behavior consistent across middleware versions while allowing each runtime to use its native discovery semantics.
The proposed approach is validated through experiments with fundamental ROS communication patterns and through the robotics use case of the PEER project (https://peer-ai.eu/en/), where INESC TEC is developing a mobile manipulator to address the need for the creation and update of digital twins for internal logistics in industrial settings for SONAE, one of the largest European retail corporations.
The remainder of this paper is organized as follows. Section 2 surveys state-of-the-art DevOps, CI/CD, containerization, and container orchestration practices for robotic software. Section 3 describes the proposed approach and methodology. Section 4 presents the validation results and discussion, using two complementary evaluation methods. Finally, Section 5 summarizes the conclusions and outlines directions for future work.

3. Proposed Approach and Methodology

This section presents our Kubernetes-based orchestration approach, detailing its high-level structure, design choices, and implementation. Our solution extends the Rigel framework to incorporate essential cloud-native orchestration capabilities specifically for ROS-based robotics applications. We begin with a framework overview of the orchestration module’s key features, followed by an in-depth examination of its internal architecture and core implementation strategies, emphasizing critical elements such as readiness and health checks, persistent data management, observability, and seamless integration with robotic development workflows.

3.1. Framework Overview

Although Rigel standardizes container builds and CI/CD testing, it leaves runtime orchestration to developers. This paper contributes a Kubernetes orchestration layer that automates deployment, rolling updates, distributed scheduling, and observability for ROS applications, extending Rigel with cluster-level capabilities while re-using its build-and-test pipeline.
Our module provides a Kubernetes orchestration layer inside Rigel, enabling Kubernetes-native functionalities for ROS deployments, including readiness-gated rolling updates via Kubernetes Deployment objects; ROS-aware readiness probes that delay termination until nodes are idle or stable; distributed deployments across edge and cloud servers; observability via pre-configured Prometheus (https://prometheus.io/), Grafana (https://grafana.com/), and Loki (https://grafana.com/oss/loki/—accessed on 7 July 2026); and ROS networking simplifying network setup and probe design.

3.2. Architecture and Implementation

At a high level, the plugin sits between Rigel’s job engine and the Kubernetes control plane (Figure 1). When a user invokes deploy_k8s, the job engine instantiates an OrchestrationPlugin that generates Kubernetes manifests: a Deployment or StatefulSet for each ROS workspace image, a singleton Deployment for ROS Master (ROS 1), Service objects for port exposure, and optionally Prometheus, Loki, and Grafana for monitoring. The plugin submits manifests via the Kubernetes Python client and watches pod events until all workloads reach the Ready state. Rigel retains image-build and registry duties; the plugin extends its pipeline into runtime.
Figure 1. High-level architecture of the orchestration plugin within the Rigel framework.
Figure 2 expands the internal structure of the plugin itself. At its core, the plugin is organized around four collaborating managers. The ResourceBuilder translates configuration models into concrete Kubernetes YAML fragments—Deployment, Service, PersistentVolumeClaim, and ConfigMap—and merges any user-supplied overrides with sensible defaults through a recursive routine.
Figure 2. Detailed architecture of the orchestration plugin within the Rigel framework.
Next, the ProbeManager traverses each container specification and injects a ROS-aware readiness probe that waits either for successful node registration or for the completion of the current goal (in Action servers).
Complementing these, the VolumeManager provisions host-backed or cloud-backed Persistent Volumes, mounts them into the appropriate pod templates, and labels them so they automatically reattach during rolling updates.
Finally, the ObservabilityDeployer stands ready to instantiate Prometheus, Loki, and Grafana on demand, wiring Prometheus scrape targets to every ROS container and importing a default dashboard that charts CPU, memory, and message-drop counters, which users can further customize.
These managers collaborate through event callbacks: on_prepare (schema validation), on_render (manifest generation), on_apply (Kubernetes submission), and on_monitor (post-deployment health). This partitioning keeps the plugin extensible; adding a GPU-aware scheduler, for example, requires only a new DeviceManager and does not alter existing code paths.
The deployment workflow (Figure 3) begins when the user triggers deploy_k8s via Rigel, prompting the job engine to instantiate OrchestrationPlugin. The plugin parses and validates the Rigelfile, generates Kubernetes manifests (Deployment/StatefulSet for each ROS workspace image, Deployment for ROS Master if applicable, and Service objects), submits them to the cluster via the Kubernetes Python client, and monitors pods until all reach Ready state, signifying a successful deployment.
Figure 3. Sequence diagram illustrating the deployment workflow for a ROS application using the orchestration plugin.

3.2.1. Readiness and Health Checks

Rolling updates of ROS applications must not disrupt ongoing operations or cause message loss during node transitions, especially in safety-critical scenarios where abrupt node shutdown could endanger the robot or its environment.
We define a critical task as any ROS communication operation that, if interrupted abruptly, leads to application-level errors, data loss, or systemic instability. Standard Kubernetes rolling updates terminate old pods immediately without regard to application state, posing risks to ROS communication patterns: interrupting synchronous Services leaves clients in perpetual waiting states, triggering timeouts and cascading failures; terminating Action servers during goal execution loses partial progress and necessitates costly restarts; and abrupt cessation of Publisher-Subscriber streams disrupts high-frequency data continuity, compromising downstream sensor fusion, navigation, and real-time control loops.
Our orchestration module implements ROS-aware readiness probes that gate the rolling update process by extending Kubernetes’ native readiness probe mechanism with ROS-specific logic. A ROS node is considered ready for termination only when idle or at a natural breakpoint where it can safely hand over responsibilities to its replacement. This approach shifts from treating robotic applications as generic containerized workloads to respecting their unique operational semantics.
The orchestration plugin automatically detects ROS communication patterns by inspecting container launch configurations and applies appropriate readiness checks. For Action servers, it injects a readiness script monitoring the status topic until goal completion. For publisher/subscriber nodes, it verifies topic registration and establishment. For ROS Service servers, it ensures pending requests are fully processed before allowing termination.
The plugin manages version-specific ROS networking requirements. For ROS 1, it injects environment variables such as ROS_MASTER_URI to enable centralized connectivity. For ROS 2, it handles decentralized DDS discovery via User Datagram Protocol (UDP) multicast or static peer lists governed by ROS_DOMAIN_ID, eliminating the ROS Master as a single point of failure but requiring the orchestration layer to manage multicast reachability across Kubernetes pods and DDS participant discovery boundaries.
Readiness probes are designed to be robust against network partitions and transient failures. During startup, if a node cannot immediately connect to its ROS infrastructure (Master for ROS 1, DDS peers for ROS 2), the probe retries with exponential backoff, preventing premature Pod restarts. During shutdown, bounded timeouts (typically 30–60 s) are enforced: if a node cannot reach a stable state within this window, the system proceeds with termination to prevent rolling updates from blocking indefinitely. For ROS 2, startup transient discovery failures are handled similarly with exponential backoff; shutdown checks are based on DDS discovery convergence and endpoint availability (topics, services, actions), with the same timeout guarantees.
This automation significantly reduces the integration burden—developers only need to specify their standard ROS launch files, and the orchestration system handles the rest.

3.2.2. Persistent Volumes

Robotic applications fundamentally differ from stateless web services in that they require persistent data that survive container restarts, updates, and hardware failures. Unlike traditional web applications that store state in external databases, ROS applications expect direct filesystem access to critical data—sensor calibration, navigation maps, learned models, and logs—reflecting their historical development on single-machine deployments where persistent local storage was assumed.
Distributed, containerized deployments fundamentally challenge this persistence model: containers are inherently ephemeral, and when Pods terminate during rolling updates, all filesystem data are permanently lost. For robotics applications, this ephemeral nature is catastrophic. Consider a mobile robot performing autonomous navigation in an unknown environment. Over the course of its operating hours, it incrementally builds a detailed occupancy grid map. If the robot’s Pod terminates during a rolling update, this entire map is lost—the robot must restart mapping from scratch, negating all computational progress and forcing significant delays in navigation tasks.
Sensor data logging presents another persistent challenge in distributed deployments. Robotic systems record high-frequency sensor streams—for post-mission analysis, debugging, and compliance—generating gigabytes per hour. These logs must survive software updates to maintain operational continuity, yet storing them in container filesystems becomes untenable with frequent deployments.
The proposed orchestration module addresses these challenges through intelligent persistent volume management that abstracts the complexity of distributed storage while preserving the filesystem interface that ROS applications expect. It analyzes the Rigelfile to identify storage-dependent containers and provisions Kubernetes PersistentVolume resources, backed by local storage or cloud solutions such as Amazon Elastic File System (EFS).
The orchestration system integrates seamlessly with ROS workflows: developers specify which directories require persistence—sensor logs, navigation data—and the system automatically handles Kubernetes volume provisioning, mounting, and lifecycle management. During rolling updates, persistent volumes are detached from terminating pods and immediately reattached to replacements, maintaining data continuity without application-level modifications.
The implementation supports multiple storage classes to accommodate different performance and durability requirements. High-frequency sensor logging might use local SSD storage for optimal write performance, while less frequently accessed data, such as configuration files, could leverage network-attached storage for better availability and backup integration. The system also automatically handles volume labeling and affinity rules to ensure that pods are scheduled on nodes where their required persistent data are accessible.
From a developer perspective, this persistent volume management eliminates the traditional trade-off between containerization benefits and data persistence requirements. ROS applications can be fully containerized and benefit from Kubernetes’ orchestration capabilities while retaining the persistent filesystem semantics they were designed around.
The system also provides built-in backup and recovery mechanisms for critical persistent data. Volumes can be automatically snapshotted at configurable intervals, and the orchestration system can restore from these snapshots in case of hardware failures or data corruption. This capability is particularly valuable for mission-critical robotic deployments where data loss could result in expensive operational downtime or safety incidents.

3.2.3. Observability Stack

When ROS nodes span multiple containers, hosts, or geographic locations, system behavior becomes exponentially complex. Performance bottlenecks can manifest unexpectedly—a sensor node on an edge device may affect cloud-based planning algorithms. However, causality is often obscured. Network partitions, resource contention, and cascading failures demand observability to diagnose and resolve quickly, especially in production where downtime incurs operational costs or safety risks.
The observability challenge in robotics is further complicated by the heterogeneity of the data to be monitored. Unlike web applications that primarily handle HTTP requests and database queries, robotic systems generate diverse telemetry streams: real-time sensor readings, control-loop frequencies, message-queue depths, actuator health status, and algorithmic convergence metrics. These data exist in two fundamentally different forms: metrics and logs, each serving distinct but complementary roles in system understanding.
Metrics capture quantitative, time-series operational data at regular intervals. In robotic systems, they encompass infrastructure measurements—CPU, memory, throughput—and domain-specific indicators such as message publication rates, action response times, and sensor quality scores. These time series enable trend analysis, alerting, and optimization: monitoring lidar frequency reveals sensor degradation before navigation failures, while tracking memory patterns predicts resource exhaustion.
Logs record discrete system events in textual detail. ROS applications generate extensive output: node startup sequences, service call traces, error conditions, and diagnostic messages. Unlike metrics, logs provide contextual details essential for root-cause analysis. A dropped message appears as a metric counter increment; the corresponding log entries reveal which topic was affected, the event sequence leading to the drop, and the contributing error conditions.
Our orchestration module integrates a comprehensive ROS-aware observability stack for the collection of metrics and logs. The metrics component—implemented with Prometheus—automatically discovers and scrapes metrics from deployed containers via Kubernetes service discovery, eliminating manual configuration. Containers automatically receive standard infrastructure metrics (CPU, memory, network I/O); the system optionally injects ROS-specific exporters that monitor message publication rates, service call latencies, and action server performance.
The metrics collection seamlessly integrates with containerized ROS deployments through automatic service annotations. When the orchestration system deploys a container, it automatically adds Prometheus scraping metadata, enabling the metrics collection system to discover and monitor the container without manual intervention.
Complementing the metrics infrastructure, the log aggregation component—implemented using Loki—provides centralized collection and indexing of textual log streams from all containers. Our approach leverages a lightweight log aggregation system specifically designed for cloud-native workloads, automatically collecting logs from all containers while maintaining minimal resource overhead.
The log aggregation system is particularly valuable for ROS applications, as it preserves contextual information that metrics alone cannot capture. For instance, when a navigation algorithm fails to find a path, metrics may only indicate increased CPU usage and elevated error counts. In contrast, logs provide detailed records of obstacle configurations, sensor readings, and algorithmic states leading to the failure. By centralizing and indexing these logs across the distributed system, operators can efficiently correlate events across nodes to diagnose complex failure modes.
The visualization and alerting component—implemented with Grafana—provides unified dashboards that integrate metrics and logs for a coherent operational view. Instead of requiring operators to navigate multiple interfaces, the system provides pre-configured, robotics-specific dashboards. These dashboards present both high-level system health (resource utilization, message throughput) and granular component status (node performance, communication patterns) in unified views, enabling rapid situational assessment.
The observability infrastructure is designed to be minimally intrusive to existing ROS applications while providing maximum operational insight. Applications require no modification to benefit from basic monitoring, while those that need specialized metrics can integrate lightweight instrumentation libraries.

3.2.4. Workflow Integration

Instead of adopting a separate orchestration tool with a distinct configuration syntax and deployment steps, the module integrates with Rigel’s existing workflow via a Rigelfile. Acting as the single source of truth, this file governs the entire application lifecycle—from containerization to production deployment—eliminating the need for developers to learn multiple configuration formats or tools.
The Rigelfile employs a declarative YAML schema to define each stage of the development pipeline: building Docker images, running tests, pushing artifacts to registries, and—via the new orchestration module—deploying and managing Kubernetes containers. This unified, version-controlled configuration allows developers to encapsulate the entire deployment pipeline in a single file alongside their code, ensuring deployment settings stay synchronized with application updates and are reviewable through standard code review processes.
The integration uses Rigel’s job-based architecture, in which each pipeline stage is a discrete, independently executable job. The orchestration module introduces the deploy_k8s job, which manages both initial deployments and rolling updates based on cluster state. This job integrates seamlessly with Rigel’s existing jobs, consolidating multiple stages into a coherent workflow that enables end-to-end automation via job sequences.
The deploy_k8s job supports a comprehensive configuration schema that abstracts Kubernetes complexity while retaining flexibility for advanced use. Key sections include rolling_update parameters for readiness-gated strategies, readiness specifications for ROS-aware health checks, persistent_storage definitions for data retention, and observability monitoring settings. Each section offers sensible defaults for typical robotic deployments while permitting customization. Listing 1 presents a representative configuration that balances simplicity and extensibility.
Following Rigel’s loading conventions, the cluster block manages infrastructure through the context parameter, enabling seamless switching between development and production clusters. Logical isolation is maintained via the namespace parameter, which defaults to rigel-default to ensure predictable behavior.
Listing 1. Representative Rigel orchestration configuration.

deploy_k8s :
  plugin : “rigel_k8s.OrchestrationPlugin”
  with :
    orchestration :
      cluster :
        context : “minikube”
        namespace : “robotics –demo”

      rolling_update :
        strategy : “RollingUpdate”
        max_unavailable : 0
        max_surge : 1

      readiness :
        enabled : true
        timeout_seconds : 60

      persistent_storage :
        volumes :
          – name : “sensor – logs”
             path : “/data/logs”
             size : “10Gi”
             storage_class : “local –ssd”

      observability :
        prometheus : true
        grafana : true
        loki : true

      additional_k8s_params :
        deployment :
          spec :
            template :
              spec :
                securityContext :
                  runAsUser : 1000
For example, the rolling update configuration enforces max_unavailable: 0 and max_surge: 1 to maintain at least one active service instance during updates—critical for uninterrupted sensor streams and robotic tasks. This reflects the operational necessity of avoiding service interruptions in robotic systems. The readiness configuration supports custom ROS-aware health checks, such as waiting for ROS Action servers to complete goals before pod termination. The 60-s timeout accommodates ROS node initialization (e.g., parameter server connections, sensor calibration), which often exceeds typical web application defaults (5–10 s). Exceeding this timeout risks node overlapping and functional redundancy. These values are illustrative, not prescriptive: users may adjust max_unavailable, max_surge, and timeouts based on their operational needs. For instance, swapping these parameters would allow brief downtime while eliminating the risk of node overlap. The configurability mechanism itself enables strategies tailored to diverse system constraints and reliability requirements.
The persistent_storage block simplifies PersistentVolumeClaim management by intelligently mounting volumes to preserve data across restarts. By specifying the storage_class (e.g., local-ssd for high-performance sensor processing), the system optimizes for workload demands while validating backends during deployment to avoid runtime failures. Observability is streamlined via automated Prometheus, Grafana, and Loki configurations with sensible defaults, including ROS-specific metrics, pre-built dashboards for topic throughput, and log aggregation for comprehensive troubleshooting.
The orchestration module’s additional_k8s_params section provides an escape hatch for advanced users. These arbitrary YAML fragments are integrated using a deep_merge algorithm, allowing users to override generated manifests without requiring comprehensive Kubernetes expertise.
An important aspect of the workflow integration is its handling of environment-specific configurations. The orchestration module supports multiple deployment targets through Rigel’s existing environment system, allowing developers to maintain separate configurations for development, staging, and production clusters.
The integration tackles the robotics challenge of managing secrets and sensitive configurations. It automates Kubernetes secret creation for container registry credentials and provides secure methods for injecting environment variables and configuration files into ROS containers. The workflow includes multi-stage validation, with pre-deployment cluster connectivity checks that deliver clear error messages, reducing troubleshooting time for configuration issues.

3.2.5. Plugin Integration Architecture

The orchestration module integrates with Rigel via its plugin system, implementing the standard PluginBase interface, which defines the contract for all framework extensions. This integration follows Rigel’s event-driven architecture, where the job engine dispatches specific lifecycle callbacks to registered plugins during job execution phases.
The OrchestrationPlugin class implements four critical lifecycle callbacks that correspond to distinct phases of the deployment process: on_prepare, on_render, on_apply, and on_monitor.
The on_prepare callback performs configuration validation and prerequisite checks. It validates the YAML configuration to ensure all required parameters are present and correctly typed, while verifying Kubernetes cluster connectivity, namespace permissions, and the existence of referenced storage classes and contexts. This early validation mitigates deployment failures by providing clear error messages that guide users toward correct configuration.
The on_render callback converts high-level configuration into Kubernetes manifests by orchestrating four internal managers: ResourceBuilder, ProbeManager, VolumeManager, and ObservabilityDeployer. The ResourceBuilder translates Rigelfile settings into Kubernetes YAML, while the ProbeManager injects ROS-aware readiness checks based on node types. The VolumeManager provisions persistent storage, and the ObservabilityDeployer generates monitoring manifests as needed. These managers coordinate via shared state and event passing to ensure consistent manifest generation.
The on_apply callback submits generated manifests to the Kubernetes cluster using the official Python3 client library (https://github.com/kubernetes-client/python—accessed on 7 July 2026). It incorporates error handling and retry logic to address transient cluster issues, partial failures, and resource conflicts.
The on_monitor callback implements a post-deployment health-check loop that waits for all pods to reach the Ready state. This includes ROS-specific readiness verification, accounting for the extended initialization time required for hardware calibration, model loading, or dependency chains. The logic incorporates timeout handling and progress reporting.

4. Results and Discussion

This section evaluates the Kubernetes-based orchestration module for ROS applications through two complementary approaches: (i) validating core orchestration capabilities using fundamental ROS patterns (Services, Actions, and Pub/Sub) to assess rolling update continuity and message integrity (Section 4.1); and (ii) assessing the PEER project platform by comparing Rigel-Kubernetes against Docker Compose for baseline metrics to quantify real-world operational trade-offs (Section 4.5.1). The Docker Compose comparison is not intended to assess functional equivalence.
The evaluation used two execution environments, summarized in Table 1: (i) a constrained AWS t2.medium virtual machine (VM) for the fundamental ROS communication-pattern trials, and (ii) a higher-capacity workstation for the PEER platform experiments.
Table 1. Comparison of hardware and software configurations for the two validation environments.
The VM was kept intentionally lean (only SSH and experimental workloads), and host monitoring confirmed stable conditions before each trial. The PEER campaign used the workstation profile in Table 1, which provided the extra CPU/GPU and storage capacity needed for orchestration, simulation, and observability services.

4.1. Fundamental ROS Communication Pattern Validation

This validation examines core orchestration capabilities using three fundamental ROS communication patterns: Services, Actions, and Publish-Subscribe. The experimental design isolates orchestration overhead from implementation complexity by employing minimal applications. Using a simple Minikube configuration does not limit its validity, as the plugin functions independently of cluster-specific details.

Experimental Setup

The orchestration module was evaluated on a VM (Table 1) using a local Kubernetes (Minikube) cluster. Three minimal ROS applications were used to isolate the following communication patterns:
  • Service-based: An arithmetic server (addition, multiplication) and a periodic client. This scenario verifies the integrity of synchronous request–response pairs during rolling updates.
  • Action-based: An Action server performing prime factorization with intermediate feedback. This tests the module’s ability to manage updates without interrupting long-running, asynchronous tasks.
  • Pub/Sub: A simulated sensor node publishing data at 500 Hz. A subscriber node computes statistics on the incoming stream and evaluates the module’s handling of readiness checks to prevent message loss during high-frequency data streaming.
Each application’s architectural layout is illustrated in Figure 4, Figure 5 and Figure 6, which depict the node relationships and the data flow for each test scenario.
Figure 4. Diagram of the minimal Action application.
Figure 5. Diagram of the minimal Pub/Sub application.
Figure 6. Diagram of the minimal Service application.

4.2. PEER Project

The PEER project serves as the primary validation case, comprising an industrially motivated robotic software stack with two components: a mobile manipulator robot (peer_robot) and a simulation environment (peer_simulation).
The peer_robot implements a task execution system using SCXML state machines to coordinate multiple ROS action servers: navigation (SimulatedOmniDriveSkill), camera capture (CaptureSkill), object identification (ObjectIdentificationSkill), and environmental observation (PEERObservationSkill). Each skill operates as a dedicated ROS action server with defined resource requirements and dependencies.
peer_simulation provides a Gazebo-based virtual environment for evaluating orchestration performance under computational loads. The simulation includes physics-based dynamics, sensor emulation, and JSON-driven world model generation, representing intensive workloads.
From a Kubernetes orchestration perspective, PEER presents several validation opportunities:
  • Rolling Update Complexity: Action servers handle long-running goals (30–60 s). ROS-aware readiness probes ensure active goals are completed before container termination, preserving mission continuity.
  • Inter-Container Dependencies: Skill servers coordinate via the ROS Master, while simulation components require initialization sequencing to ensure world loading precedes robot spawning.
  • Persistent Data Requirements: Navigation maps, sensor calibration data, and mission logs must survive software updates. Persistent volume management preserves these critical operational data.
  • Resource Heterogeneity: The simulation requires GPU resources for physics computation, while robot controllers need guaranteed CPU allocation for performance.
  • Observability Needs: The observability stack provides centralized logging and metrics collection to debug state machine execution and multi-component interaction.

PEER Configuration Management and Orchestration

PEER leverages Kubernetes ConfigMaps to manage operational parameters, including sensor calibration (camera topics, point cloud settings), spatial reference frames (origin_frame, camera_frame, observation_frame), and mission parameters (confidence thresholds, waypoint coordinates).
During rolling updates, the module ensures container instances receive updated configurations while maintaining inter-component consistency. For example, the capture_skill and object_identification_skill servers must align on topic names and coordinate frame definitions.
Persistent volume requirements span navigation maps, sensor calibration data, mission logs, and SCXML execution state, with the simulation additionally needing 3D models and preserved physics state. The orchestration provisions, mounts, and reattaches storage based on container-specific needs.
Resource demands range from GPU-intensive Gazebo simulation and sensor rendering in peer_simulation to CPU-bound skill servers requiring predictable allocation for real-time performance. The system balances these needs through strategic node placement.

4.3. Experimental Methodology and Metrics Collection

Each experimental scenario followed a protocol capturing steady-state performance and transient behavior during rolling updates. Ten independent trials per scenario were conducted, each including a 60 s stabilization period for container startup and ROS node registration.
Steady-state metrics were collected over 5 min under nominal workloads: (i) 10 Hz Services; (ii) Action goals (prime factorization of integers 1000–9999); and (iii) 500 Hz Pub/Sub streams. Rolling updates were initiated via the deploy_k8s job, involving logic changes (e.g., addition to subtraction), dependency updates (NumPy), or container tag modifications. Pod readiness verification ensured new containers were operational before terminating old instances.
Metrics were collected via Prometheus at 15-s intervals, tracking CPU, memory, and network I/O, as well as ROS-specific latencies and publication rates. Task monitoring employed request–response logging for Services, lifecycle tracking for Actions, and sequence numbering with gap detection for Pub/Sub streams to detect discontinuities with microsecond precision.
Controlled stress testing used stress-ng (80% CPU/memory pressure) and k6 v0.55.0 for request-level load, validating performance under edge-computing-like contention.
Statistical analysis used 95th-percentile (p95) measurements to capture tail behavior. Results are reported with 95% confidence intervals.

4.4. Key Findings

Readiness-Gated Rolling Updates

Experimental validation confirmed that all three workloads maintained operational continuity during container replacements, with measured interruption windows consistently in the millisecond range across all scenarios. These results indicate low-interruption rolling updates rather than strict zero-downtime behavior.
For the Service-based scenario, quantitative analysis across 10 trials showed zero dropped requests under all update conditions. Table 2 presents the detailed metrics, showing that, during steady-state operation, the system maintained 23.4% CPU usage (±2.5%) and 280 MB memory consumption (±30 MB), with 95th percentile request latency of 45 ms. During rolling updates, CPU usage increased to 28.1% (±3.2%) and memory to 290 MB (±35 MB), while request latency increased to 83 ms, representing an acceptable 84% latency increase while maintaining zero request failures.
Table 2. Metrics for the Service scenario (mean of 10 trials).
The Action-based scenario ensured robust protection of long-running tasks during updates. ROS action server latency results (Table 3) indicate task completion time increased from 220 ms under normal conditions to 388 ms during updates—a 76% rise—but with zero interruptions or aborted actions across all trials. This degradation remained within acceptable bounds for non-real-time robotics tasks while preserving computational integrity.
Table 3. Action server performance (mean of 10 trials).
The high-frequency Pub/Sub scenario maintained high message integrity during rolling updates. Across 100,000 messages per trial, minor subscriber updates incurred 0.008% loss (8 messages), major subscriber updates 0.007% (7 messages), and simultaneous publisher-subscriber updates 0.017% (17 messages). These results demonstrate >99.99% message integrity across all scenarios, though transient disruption persists for high-frequency streams in the tested configuration.
The readiness logic effectively coordinated pod lifecycle transitions, ensuring that new pods reached operational readiness before old ones were terminated. This was particularly evident in protecting critical tasks (Section 3) during rolling updates. In the Service-based scenario, active arithmetic request–response transactions remained uninterrupted, preventing client timeouts and ensuring zero dropped requests. For the Action-based scenario, running prime factorization goals continued uninterrupted, even during updates, preserving partial computation and avoiding the need for client restarts. The Pub/Sub scenario (500 Hz sensor streams) experienced brief interruptions: 16 ms (minor updates), 14 ms (major updates), and 34 ms (simultaneous updates), demonstrating the effectiveness of ROS-aware readiness probes in minimizing—but not eliminating—disruption.
Rolling update performance overhead remained within acceptable limits, with CPU spikes constrained to 10–15% above baseline. Memory overhead was similarly modest, as the observability stack required under 300 MB of additional memory—well-suited for resource-constrained edge robotics platforms.
Figure 7 provides a view of the latency characteristics observed across all three ROS communication patterns, demonstrating the predictable performance degradation during rolling updates while maintaining acceptable response times for robotics applications.
Figure 7. Latency distribution across Service, Action, and Publish-Subscribe communication patterns during steady-state and rolling update operations, illustrating the performance characteristics of each ROS communication type.

4.5. Performance Analysis and System Behavior

Performance evaluation revealed specific quantitative overhead characteristics. During rolling updates, CPU utilization showed predictable spikes: container image pulling consumed an additional 3–5% of CPU for 10–20 s, while initialization required an additional 5–8% overhead. Total CPU overhead during updates remained 10–15% above baseline levels across all scenarios.
Memory usage followed consistent patterns. Baseline consumption averaged 250–300 MB per ROS container, with the observability stack adding 300 MB. Temporary memory peaks during updates increased by <50 MB per deployment due to parallel execution. Under 80% CPU stress, the system maintained stable memory management with zero out-of-memory (OOM) terminations.
Network analysis showed minimal orchestration impact. Service-based scenarios generated <1 MB/min of traffic, while 500 Hz Pub/Sub scenarios reached  15 MB/min. Monitoring infrastructure added <2% overhead to baseline bandwidth. p95 latencies remained under 100 ms for local cluster communication.
Stress testing validated resilience under resource contention. With 80% CPU load (stress-ng), application response times increased by 40–60%. Figure 8 and Figure 9 show baseline Pub/Sub performance, while Figure 10 and Figure 11 demonstrate behavior under 80% CPU stress. Rolling update completion times extended by approximately 50% under stress, with no application failures or data corruption.
Figure 8. Pub/Sub message latency under 0% CPU load.
Figure 9. Pub/Sub mean message latency under 0% CPU load.
Figure 10. Pub/Sub message latency under 80% CPU load.
Figure 11. Pub/Sub mean message latency under 80% CPU load.
System recovery behavior under simulated failures demonstrated operational resilience with measurable recovery times. Kubernetes failure recovery mechanisms handled pod failures effectively, with replacement containers reaching operational status within 30–45 s. Persistent volume management ensured 100% data continuity during recovery, with zero data loss across all tested scenarios. The observability stack maintained continuous monitoring throughout failures, offering immediate visibility into state transitions and recovery progress.

4.5.1. PEER Project Validation: Complex Simulated System Deployment

The PEER project—developed at INESC TEC for retail environment analysis—integrates a mobile manipulator robot with a high-fidelity simulation environment, multiple ROS action servers, distributed sensing pipelines, and mission-level state machine orchestration. Its generative Artificial Intelligence (AI) workflow maintains a continuously updated digital twin of supermarket shelves by extracting visual and textual data from captured imagery, enabling rapid adaptation to dynamic product layouts. This modular architecture imposes heterogeneous computational demands on the orchestration layer, making PEER a suitable testbed for evaluating Kubernetes-based coordination of realistic robotic workloads. Figure 12 depicts the PEER simulation environment, illustrating the setup used for the workstation-based validation of the orchestration framework.
Figure 12. PEER project simulation environment used for orchestration validation.
Validating the orchestration approach using PEER yielded critical insights into the framework’s performance on a complex robotics stack. All metrics in this subsection refer to the workstation profile in Table 1, which provides the GPU resources and storage throughput required by the full Gazebo-based stack. The PEER deployment coordinated 12 distinct containers—one per ROS node—across robot control, simulation, and supporting services, offering a realistic integration workload short of industrial-scale validation. Figure 13 visualizes the observed performance characteristics.
Figure 13. PEER platform deployment comparison showing resource utilization and performance characteristics during workstation-based simulation validation.
The PEER validation demonstrated the framework’s ability to manage a complex, interdependent robotic stack with acceptable performance in a workstation-based simulation. Measured resource overhead and deployment times suggest Kubernetes can be integrated into ROS workflows at manageable costs. However, further testing on physical robots and multi-node clusters is needed before asserting production-readiness.
  • Multi-Container Orchestration Performance: The modular architecture—including skill servers (capture_skill, object_identification, simulated_omni_drive_skill, peer_observation_skill)—validated the framework’s handling of inter-container dependencies. The module enforced service dependencies, ensuring the ROS Master was initialized before skill servers. Across 25 trials, the ROS Master averaged 1.56 s to readiness, while individual skill servers achieved operational status in 2.5–3.0 s.
  • SCXML State Machine Coordination: SCXML-based mission execution served as a testbed for rolling updates with stateful, long-running tasks. Missions (3–5 min each) remained uninterrupted during trials, because ROS-aware readiness probes detected ongoing action server goals, thereby postponing container termination until mission segments were completed. Across 25 trials with rolling updates during active missions, no state machine executions required restart.
  • Simulation Environment Coordination: The peer_simulation component validated the handling of GPU-intensive workloads. The container received appropriate resource allocation through Kubernetes node selection. During updates, the system coordinated the shutdown of dependent robot containers, updated the simulation, and re-established communication without manual intervention. Complete simulation environment replacement averaged 12.6 s.
  • ConfigMap and Persistent Storage Validation: The system managed 15 distinct configuration files across three ConfigMap objects, containing mission parameters, waypoint definitions, and skill configurations. During rolling updates, changes were propagated to replacement containers without affecting ongoing missions, validating the ability to handle configuration interdependencies.
  • Observability Across Multiple Containers: The PEER deployment comprised 12 containers generating metrics streams from skill servers, simulation, and coordination services. Prometheus collected over 200 distinct metrics, while Loki processed 150–300 log lines per second. Dashboard response times stayed under 2 s, with monitoring overhead at 619 MB memory and 8.56% CPU-scalable within the workstation setup. The 619 MB memory usage (vs. 300 MB baseline) reflects the observability stack’s dynamic scaling with data volume, driven by the additional logs and metrics from the more complex experimental scenario.
  • Operational Insights from Simulation: Mission failure recovery demonstrated how health checks and restart policies interact with robotic state machines. When individual skill servers experienced failures (introduced through resource starvation), Kubernetes restart policies and ROS service discovery enabled automatic recovery, typically restoring capability within 15–30 s.
  • Resource Allocation and Scaling: CPU allocation requests ranged from 100 millicores for simple nodes to 500 millicores for simulation, with memory requests spanning 128 MB to 2 GB. The Kubernetes scheduler co-located compatible workloads while respecting constraints, achieving 75–85% cluster resource utilization efficiency during peak operation.
The PEER validation confirmed the framework’s ability to orchestrate 12 interdependent containers while maintaining mission continuity, handling complex configurations, and delivering comprehensive observability in a realistic simulated workload. These results validate the approach as a development and integration tool, though production readiness requires validation on physical robots, realistic networks, and multi-node Kubernetes infrastructure. Performance remained within acceptable bounds, with orchestration overhead contributing less than 9% to total system resource consumption.

4.5.2. Technical Insights from PEER Deployment

The PEER project deployment revealed several technical insights useful for understanding the practical implications of Kubernetes orchestration in complex robotics software stacks. However, they were not apparent from the simplified communication-pattern experiments.
  • State Machine Coordination and Container Lifecycle: The interaction between PEER’s SCXML state machines and Kubernetes container lifecycle management highlighted the importance of semantic-aware orchestration. Unlike basic publisher-subscriber models, state machines maintain intricate execution contexts spanning multiple ROS actions and decision points. Validation revealed that state machine states must be preserved across the entire mission workflow, not just at individual action levels. The orchestration module’s readiness probes aligned with state machine boundaries, ensuring updates occurred only during natural transitions between mission phases—avoiding interruptions to ongoing skill executions.
  • Multi-Level Configuration Dependencies: PEER’s configuration hierarchy—spanning individual skill parameters, mission definitions, and SCXML templates—highlighted the complexity of managing interdependent configurations in distributed robotics. The system exposed configuration propagation challenges: altering sensor topic names in the capture skill required consistent updates across object identification parameters, spatial reference frames, and mission files. The orchestration module’s ConfigMap validation effectively enforced these consistency requirements, blocking deployments with incompatible configurations.
  • Resource Allocation Trade-offs in Mixed Workloads: Co-deploying PEER’s simulation with robot control components revealed robotics-specific resource allocation challenges. The simulation’s intermittent GPU usage (high during physics computation, low during idle periods) introduced scheduling complexities alongside the robot controllers’ consistent CPU demands. Validation confirmed that effective robotics orchestration requires workload awareness beyond basic CPU/memory metrics, accounting for simulation, perception, and control algorithm patterns.
  • Debugging and Observability Across the Stack: The observability stack’s performance with PEER’s 12-container deployment highlighted scaling characteristics for larger robotics systems. Cross-container log correlation during complex missions was critical for debugging failures, especially when state machine transitions involved multiple action servers. Centralized logging enabled quick identification of timing-dependent issues—such as how skill server initialization order impacted mission success—insights unobtainable from isolated container monitoring.
  • Network Discovery and Service Coordination: PEER’s distributed architecture stressed the orchestration module’s ROS networking capabilities beyond simple point-to-point communication. The system’s dynamic service discovery requirements—where skill servers must locate each other while maintaining consistent topic namespaces—validated the robustness of the ROS Master networking approach under realistic conditions. Validation confirmed that automated ROS_MASTER_URI injection and service advertisement coordination scaled effectively to systems with double-digit container counts.
These insights from PEER validation provide confidence that the orchestration approach can handle the complexity of realistic robotics software integration, addressing challenges that only become apparent when moving from prototype demonstrations to comprehensive system integration. They should be viewed as a step toward, rather than a replacement for, validation in deployed industrial robotics environments.
The quantitative analysis shown in Figure 14 and Figure 15 demonstrates the systematic evaluation approach used to validate orchestration performance relative to traditional deployment methods. The statistical rigor applied ensures that the observed performance characteristics are statistically significant and reproducible across different deployment scenarios.
Figure 14. Absolute differences comparison between Kubernetes and Docker Compose deployments during PEER project validation, highlighting the performance trade-offs of orchestration capabilities.
Figure 15. Statistical rigor visualization of PEER project deployment performance, showing confidence intervals and significance testing results for orchestration metrics comparison.

4.6. Development Workflow Impact Analysis

The performance differences have practical implications for development workflows. Based on typical robotics development patterns with approximately 50 deployments per day, the measured differences translate to the following:
  • Daily Time Overhead: +8 min per developer (50 × 9.65 s additional rolling update time).
  • Resource Cost: +198 MB memory and +3.44 percentage points CPU per deployment.
  • Infrastructure Scaling: 30–40% higher resource requirements for Kubernetes control plane.
While these overheads represent measurable costs, they remain within acceptable bounds for most robotics development teams, particularly given the comprehensive orchestration capabilities provided by the Kubernetes platform. Figure 16 demonstrates the stability and consistency of deployment performance across multiple trials, validating the reliability of our orchestration approach.
Figure 16. Improved performance trend analysis showing deployment time stability and rolling update patterns across 25 trials per platform.

5. Conclusions

This paper demonstrates that Kubernetes-based orchestration delivers operational benefits for ROS applications, with performance trade-offs remaining within acceptable bounds for robotics deployments. A comparison with Docker Compose quantified the implications of automated orchestration in robotic systems.
The PEER project validation demonstrated orchestration of 12 interdependent containers with 100% mission continuity. Measured performance included 1.56 s (±0.57) deployment time, 12.6 s (±1.22) rolling update time, and 619 MB (±18.1) memory overhead for observability. While Kubernetes incurs higher resource consumption (+198 MB memory, +3.44 percentage points CPU) and longer updates (+9.65 s) than Docker Compose, these translate to approximately 8 min of daily overhead—justified by the provided enterprise capabilities and additional orchestration infrastructure.
Research is needed for multi-cluster scenarios and real-time scheduling on edge nodes with intermittent connectivity. Distributed deployments introduce complexities in namespace management and network latency, requiring strategies such as pinning sensitive nodes to edge hardware.
We plan to investigate auto-scaling policies to dynamically move computationally heavy components from on-robot containers to cloud VMs. Because offloading tasks introduces latency that can exceed 100 ms, future work must evaluate trade-offs using adaptive strategies such as data compression. Furthermore, introducing trace reporting would benefit ROS observability.
Despite the benefits, low-interruption updates in robotics require logic to keep sensor streams and task transitions as stable as possible during container replacement.

Author Contributions

Conceptualization, R.A., P.M. and A.S.; methodology, N.H., R.A., P.M. and A.S.; software, N.H., R.A., P.M., D.J.C. and P.E.; validation, N.H. and P.M.; formal analysis, N.H.; investigation, N.H., R.A. and A.S.; resources, N.H., R.A. and P.M.; data curation, N.H., R.A. and A.S.; writing—original draft preparation, N.H.; writing—review and editing, R.A., P.M., A.S., D.J.C. and P.E.; visualization, N.H.; supervision, R.A. and A.S.; project administration, R.A.; funding acquisition, R.A. All authors have read and agreed to the published version of the manuscript.

Funding

This project has received funding from the European Union’s Horizon Europe research and innovation program under Grant Agreement 101120406.

Institutional Review Board Statement

Not applicable.

Data Availability Statement

The raw data supporting the conclusions of this article will be made available by the authors on request.

Acknowledgments

During the preparation of this work, the authors used Generative AI (Claude Haiku 4.5) to improve readability. After using this tool/service, the authors reviewed and edited the content as needed and take full responsibility for the content of the published article.

Conflicts of Interest

The authors declare no conflicts of interest.

References

  1. Arrais, R.; Veiga, G.; Ribeiro, T.T.; Oliveira, D.; Fernandes, R.; Conceição, A.G.S.; Farias, P. Application of the open scalable production system to machine tending of additive manufacturing operations by a mobile manipulator. In Proceedings of the EPIA Conference on Artificial Intelligence; Springer: Vila Real, Portugal, 2019; pp. 345–356. [Google Scholar]
  2. Hamner, B.; Koterba, S.; Shi, J.; Simmons, R.; Singh, S. An autonomous mobile manipulator for assembly tasks. Auton. Robot. 2010, 28, 131–149. [Google Scholar] [CrossRef] [Scilit]
  3. Ghodsian, N.; Benfriha, K.; Olabi, A.; Gopinath, V.; Arnou, A. Mobile manipulators in industry 4.0: A review of developments for industrial applications. Sensors 2023, 23, 8026. [Google Scholar] [PubMed]
  4. Xing, H.; Xu, Y.; Chen, J.; Li, W.; Liu, Y.; Xie, Y.; Ding, L. Multi-objective optimization with priority-based execution for mobile manipulators: An HQP approach integrating adaptive motion planning and obstacle avoidance. Robot. Auton. Syst. 2026, 201, 105457. [Google Scholar] [CrossRef] [Scilit]
  5. Kehoe, B.; Patil, S.; Abbeel, P.; Goldberg, K. A Survey of Research on Cloud Robotics and Automation. IEEE Trans. Autom. Sci. Eng. 2015, 12, 398–409. [Google Scholar] [CrossRef] [Scilit]
  6. Quigley, M.; Conley, K.; Gerkey, B.; Faust, J.; Foote, T.; Leibs, J.; Wheeler, R.; Ng, A.Y. ROS: An open-source Robot Operating System. In Proceedings of the ICRA Workshop on Open Source Software, Kobe, Japan, 12–17 May 2009; Volume 3, p. 5. [Google Scholar]
  7. Teixeira, S.; Arrais, R.; Veiga, G. Cloud Simulation for Continuous Integration and Deployment in Robotics. In Proceedings of the 2021 IEEE 19th International Conference on Industrial Informatics (INDIN), Palma de Mallorca, Spain, 21–23 July 2021; pp. 1–8. [Google Scholar] [CrossRef] [Scilit]
  8. Farley, D. Continuous Delivery Pipelines: Reliable, Repeatable, and Secure Software Delivery, 1st ed.; O’Reilly Media: Sebastopol, CA, USA, 2024; p. 300. [Google Scholar]
  9. Wilson, C. Grokking Continuous Delivery, 1st ed.; Manning Publications: Shelter Island, NY, USA, 2022; p. 320. [Google Scholar]
  10. Melo, P.; Arrais, R.; Teixeira, S.; Veiga, G. A Container-Based Framework for Developing ROS Applications. In Proceedings of the IEEE International Conference on Industrial Informatics (INDIN), Perth, Australia, 25–28 July 2022; pp. 280–285. [Google Scholar] [CrossRef] [Scilit]
  11. Burns, B.; Beda, J.; Hightower, K.; Evenson, L. Kubernetes: Up & Running, 3rd ed.; O’Reilly Media: Sebastopol, CA, USA, 2022. [Google Scholar]
  12. Zampetti, F.; Tamburri, D.A.; Panichella, S.; Panichella, A.; Canfora, G.; Penta, M.D. Continuous Integration and Delivery Practices for Cyber-Physical Systems: An Interview-Based Study. ACM Trans. Softw. Eng. Methodol. 2023, 32, 73:1–73:44. [Google Scholar] [CrossRef] [Scilit]
  13. Zeller, M. Towards Continuous Safety Assessment in Context of DevOps. In Proceedings of the Computer Safety, Reliability, and Security. SAFECOMP 2021 Workshops: DECSoS, MAPSOD, DepDevOps, USDAI, and WAISE, York, UK, 7 September 2021; Habli, I., Sujan, M., Gerasimou, S., Schoitsch, E., Bitsch, F., Eds.; Springer: Cham, Switzerland, 2021; Volume 12853, pp. 145–157. [Google Scholar] [CrossRef] [Scilit] [PubMed]
  14. Vieira, D.; Oliveira, M.; Arrais, R.; Melo, P. Application of Cloud Simulation Techniques for Robotic Software Validation. Sensors 2025, 25, 1693. [Google Scholar] [PubMed]
  15. Mañas-Álvarez, F.J.; Guinaldo, M.; Dormido, R.; Dormido-Canto, S. Scalability of cyber-physical systems with real and virtual robots in ros 2. Sensors 2023, 23, 6073. [Google Scholar] [PubMed]
  16. Salimpour, S.; Peña-Queralta, J.; Paez-Granados, D.; Heikkonen, J.; Westerlund, T. Sim-to-Real Transfer for Mobile Robots with Reinforcement Learning: From NVIDIA Isaac Sim to Gazebo and Real ROS 2 Robots. arXiv 2025, arXiv:2501.02902. [Google Scholar]
  17. Macenski, S.; Foote, T.; Gerkey, B.; Lalancette, C.; Woodall, W. Robot Operating System 2: Design, architecture, and uses in the wild. Sci. Robot. 2022, 7, eabm6074. [Google Scholar] [CrossRef] [Scilit] [PubMed]
  18. Lumpp, F.; Panato, M.; Bombieri, N.; Fummi, F. A Design Flow based on Docker and Kubernetes for ROS-based Robotic Software Applications. ACM Trans. Embed. Comput. Syst. 2023, 23, 1–24. [Google Scholar] [CrossRef] [Scilit]
  19. Hightower, K.; Burns, B.; Beda, J. Kubernetes: Up & Running: Dive into the Future of Infrastructure, 1st ed.; O’Reilly Media: Sebastopol, CA, USA, 2017; p. 240. [Google Scholar]
  20. Lumpp, F.; Fummi, F.; Patel, H.D.; Bombieri, N. Enabling Kubernetes Orchestration of Mixed-Criticality Software for Autonomous Mobile Robots. IEEE Trans. Robot. 2024, 40, 540–553. [Google Scholar] [CrossRef] [Scilit]
  21. Gu, S.; Chisom, O.; Yang, J.; Yoon, D. Cloud-Based Remote-Controlled Robot System: A Kubernetes-OrchestratedApproach to High Availability. Expert Syst. Appl. 2025, 285, 127860. [Google Scholar] [CrossRef] [Scilit]
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.

Article Metrics

Citations

Article Access Statistics

Multiple requests from the same IP address are counted as one view.