Editing Emerging Research Directions (section)

== 7.5 Data Persistence ==

===7.5.1 Introduction===

'''What is Edge Persistence?'''

Data persistence plays a crucial role in ensuring that data generated is reliably stored and managed locally or near the location, even in volatile environments. Persistence at the edge is especially important, as edge applications are often deployed in highly non-deterministic conditions. By bringing data closer to the edge, it becomes essential to ensure its reliability. Exploring persistent storage allows us to safeguard data integrity by capturing information locally until it can be properly synchronized. Edge persistence ensures that data remains accessible, secure, and consistent even in network disruptions, hardware failures, or resource constraints, which is essential for maintaining reliability in edge computing environments [8]. 

This section introduces the topic of persistence at the edge highlighting prominent challenges in the space of data integrity in distributed edge systems. This section explores three main challenges of data persistence at the edge: 

#Byzantine Faults
#Data Consistency
#Limited Resources

This section will also explore emerging solutions to these challenges that are not standardized or concrete, but serves as a direction in which to consolidate these answers to solve data integrity at the edge:

*Store-and-Forward Techniques: using message queues (MQTT or Apache Kafka) to reliably forward data when the connection resumes [6]. 

*Lightweight Databases: Use embedded databases optimized for low-resource environments (e.g., SQLite, TinyDB, or RocksDB).

*Conflict Resolution Policies: Use mechanisms like versioning, timestamps, or last-write-wins to resolve conflicting updates [5].

===7.5.2 Architectural Models for Edge Storage===


'''Overview'''

The primary goal of edge computing is to shift data processing closer to the edge, in doing so it reduces latency. Although this decentralized approach also brings challenges on how data is stored. Architectural models for edge persistence must balance [1] :

#performance
#scalability
#consistency 

'''Centralized Storages'''

In a centralized model edge nodes collect data and are sent to a central node. This model is prominent in cloud computing which simplifies data management, but also introduces latency and single point of failure [2]. Centralization offers maintainability and control over data  policies. It also is subjected to vulnerabilities in network failures[3]. 

'''Decentralized Storages'''

Decentralized storage involves storing and processing data in edge devices across a distributed system of nodes. This model offers fault tolerance and a reduction in latency, but a higher complexity of data management[4]. It offers better support for real-time applications, but a more complex model in need of more data synchronizations and data consistency[5]. 

'''Hierarchical Storage Architectures'''

Hierarchical models organize storage across tiers:

*Tier 1 (Device Level): Sensors, gateways, or IoT devices store small amounts of critical data locally.

*Tier 2 (Edge Nodes): More capable edge servers store larger volumes, perform processing, and temporarily cache data.

*Tier 3 (Cloud/Core): Central data centers serve as long-term storage and coordination points16. This tiered approach helps balance performance and cost while offering flexibility in data handling.

'''Peer-to-Peer and Mesh-Based Storage'''

Peer-to-peer (P2P) or mesh-based architectures involve edge nodes communicating directly to share and replicate data. These systems are used in scenarios with unreliable connectivity, employing techniques like gossip protocols, data sharding, and replication to maintain availability and redundancy[6].

===7.5.3 Persistence Mechanisms in Edge Devices===
'''Caching Strategies'''

Caching is a critical persistence mechanism in edge computing, as it accelerates data access by storing frequently accessed data closer to the point of use. Techniques like in-memory caching, distributed caching, and content delivery networks (CDNs) are commonly used to enhance performance and reduce latency. For instance, in-memory caching stores data directly within an application's memory space, offering the fastest access times due to its proximity to the application logic.

'''Local Databases'''

Local databases are essential for storing and managing data on edge devices. SQLite is a lightweight relational database ideal for embedded systems, mobile apps, and IoT devices due to its small footprint and ease of use. On the other hand, RocksDB is a high-performance key-value store optimized for write-heavy workloads and large-scale applications, making it suitable for edge AI solutions and real-time analytics.

'''Object Storage at the Edge'''

Object storage is increasingly used at the edge due to its scalability and flexibility. It simplifies operations by avoiding hierarchical file systems and supports peer-to-peer architectures, which enhance flexibility and efficiency across distributed computing environments. Edge object storage is particularly beneficial for handling fluctuating workloads and accommodating modern technologies like containerization and microservices.

===7.5.4 Synchronization and Data Consistency===

'''Data Consistency at the edge'''

Data consistency is an integral component of Persistence at the edge. This subcomponent refers to ensuring that data remains consistent and accurate in a distributed system where data homogeneity remains firm. The challenge of maintain data consistency is prominent because edge devices are not resilient to environmental resource scarcity, which often leads to network issues or hardware failures. Challenges of consistency include: connectivity, latency, and data integrity. A way to solve these issues are consistency protocols. [3]

'''CRDT (Conflict-Free Replicated Data Types'''

CRDTs are data structures implemented in distributed systems that allow modification independently at multiple locations, while also ensuring changes are merged without any conflicts. CRDTs are useful in edge environements where multiple replicase of data may exist and must be synchronized in local caches, or CDNs. CRDTs follow three main components: 

# Conflict Free
#Replication
#Consistency

[[File:Crdt.png|600px|thumb|center| Representation of CRDT operations]]

===7.5.5 Latency and Throughput Considerations===

Latency and throughput are two pivotal metrics that directly affect the performance and reliability of edge data persistence systems. Their impact is especially critical in applications requiring real-time response and high data fidelity, such as autonomous vehicles, industrial automation, and AR/VR systems.

Latency refers to the time delay from the generation of data to its availability for consumption or action. Edge computing reduces this delay by processing and storing data closer to the source, circumventing long cloud transmission cycles. However, resource constraints, task prioritization, and variable network conditions at the edge can still introduce latency. According to [1], designing adaptive reference architectures for highly uncertain environments is critical to minimizing latency and ensuring responsiveness.

Throughput, by contrast, defines the volume of data processed or transmitted within a given time. With edge deployments supporting data-intensive applications like federated learning and predictive maintenance, maintaining high throughput is essential. Federated models, as discussed in [3], rely on consistent, rapid data handling across decentralized nodes without raw data sharing, further stressing throughput capabilities.

Achieving a balance between low latency and high throughput presents architectural challenges. Caching strategies and lightweight local databases—such as SQLite and Redis—help accelerate data access and reduce I/O bottlenecks. Recent work in MQTT broker optimization using these tools demonstrates significant performance gains in edge scenarios [7]. Embedded databases like RocksDB and SQLite are also recognized for their fast read/write performance, particularly in constrained environments [9].

Edge object storage, which bypasses hierarchical file systems in favor of flat, scalable models, supports high-throughput access to unstructured data across distributed systems [10]. Partial offloading and adaptive data compression are further techniques that reduce transmission load while preserving speed and data integrity.

Data consistency protocols also impact throughput. Conflict-Free Replicated Data Types (CRDTs) [6] and replicated database systems [5] allow updates to propagate across distributed nodes without costly synchronization steps, maintaining system fluidity. These solutions enable high availability while tolerating intermittent connections and reducing coordination overhead.

As edge systems continue to evolve, future research must address bottlenecks by integrating intelligent scheduling, data-aware caching, and predictive throughput modeling. Techniques like edge-aware sharding [11] and fault-tolerant consensus algorithms [2] are among promising directions to ensure edge persistence systems can scale effectively while delivering low-latency and high-throughput performance.

===7.5.6 Fault Tolerance and Recovery===

'''Byzantine Faults at the Edge'''

Byzantine faults refer to an issue where in some distributed system, nodes (devices) may behave un predictably due to failures or attacks. Faulty nodes may send incorrect data which results in data corruption that affects other nodes in the server. This problem is essential to explore in edge systems as one main challenge of edge computing is the unreliability of resource constraint devices. Devices located to data sources tend to be highly unpredictable (e.g. IoT devices, mobile phones, or embedded systems). There are many algorithmic solutions to reduce Byzantine faults such as Bracha-Toueg Byzantine consensus algorithm, Mahaney-Schneider synchronizer, and other consensus algorithms, 

[[File:Bracha-Toueg.png|600px|thumb|center| Example of consensus algorithm, Bracha-Toueg Byzantine consensus algorithm.]]

''Byzantine Generals Problem, which was introduced by Leslie Lamport, Robert Shostak, and Marshall Pease in their 1982 paper titled The Byzantine Generals Problem''

'''Case Study 1: Byzantine resilience in federate learning at the edge'''

Creative solutions in edge systems are explored in [1], Byzantine resilience in federated learning at the edge, where heavy tailed data and communication inefficiencies are main challenges presented in this paper. Federated learning is a prominent example of a edge tailored system where Byzantine resilience is essential. Authors of this paper proposed a distributed gradient descent algorithm that operates with local computations on each device where it calculates the gradient of the model based on local data. In order to trim failed nodes, the algorithm proposed uses ''coordinate-wise trimmed mean''. This algorithm is designed to follow heavy tailed distribution which ensures outliers do not affect the model. The key issues addressed in the paper is how Byzantine failures degrade the performance of federated learning systems. This solution employes robust aggregation in order to solve these issues where traditional algorithms are inapplicable.

===7.5.7 Edge Persistence in Modern Frameworks===

'''Integration with Kubernetes and K3s'''

Modern edge computing frameworks increasingly rely on Kubernetes (K8s) and its lightweight derivative K3s to manage containerized workloads at the edge. These orchestration platforms allow edge nodes to operate with greater autonomy and reliability, particularly in disconnected or resource-constrained environments. Persistent Volumes (PVs) in Kubernetes facilitate stable, long-term data storage across container lifecycles, a key requirement for edge persistence [1][2]. K3s, designed specifically for edge deployments, reduces overhead while maintaining compatibility with standard Kubernetes storage classes, enabling efficient orchestration and data management across distributed edge clusters [3].

'''Leveraging Persistent Volumes in Edge Clusters'''

Persistent Volumes enable critical applications to maintain data integrity during container restarts, node failures, and network partitions. This is especially important in edge environments where connectivity is often intermittent and fault tolerance is paramount. Strategies such as replication, snapshotting, and dynamic provisioning have been adapted from core cloud infrastructure to support edge persistence more efficiently. Lightweight block storage (e.g., SQLite) and in-memory solutions (e.g., Redis) are often used to store state and cache frequently accessed data, thereby reducing latency and maintaining responsiveness [7].

'''Edge DBs and Lightweight Orchestration Tools'''

Embedded and lightweight databases such as SQLite, DuckDB, and RocksDB are increasingly used in edge deployments due to their minimal resource requirements and robust offline capabilities [9]. These databases can seamlessly integrate with messaging systems like MQTT for real-time processing and data synchronization. To ensure consistency and eventual convergence, conflict-free replicated data types (CRDTs) have emerged as a popular model, allowing updates to propagate and resolve autonomously across distributed nodes [6]. In tandem, orchestration tools like K3s simplify cluster management while enabling operators to deploy, monitor, and update stateful services with minimal effort [3][7].

===7.5.8 Conclusion===

Edge data persistence has become a cornerstone of modern edge computing, enabling applications to operate reliably and independently even in disconnected or volatile conditions. With the integration of Kubernetes-based orchestration, persistent volume strategies, and lightweight embedded databases, developers can maintain consistency, reduce latency, and scale their edge solutions efficiently. Technologies like CRDTs, edge object storage, and federated consensus protocols further enhance fault tolerance and data availability, ensuring that edge systems remain robust, resilient, and secure across diverse deployment scenarios.

=== References ===
#arXiv, "Defining a Reference Architecture for Edge Systems in Highly Uncertain Environments," arXiv, 2024, [Online]. Available: https://arxiv.org/pdf/2406.08583.pdf.
#  G. Jing, Y. Zou, D. Yu, C. Luo and X. Cheng, "Efficient Fault-Tolerant Consensus for Collaborative Services in Edge Computing," in IEEE Transactions on Computers, vol. 72, no. 8, pp. 2139-2150, 1 Aug. 2023, doi: 10.1109/TC.2023.3238138.
# Y. Tao et al., "Byzantine-Resilient Federated Learning at Edge," in IEEE Transactions on Computers, vol. 72, no. 9, pp. 2600-2614, 1 Sept. 2023, doi: 10.1109/TC.2023.3257510.
#G. Cui et al., "Efficient Verification of Edge Data Integrity in Edge Computing Environment," in IEEE Transactions on Services Computing, vol. 15, no. 6, pp. 3233-3244, 1 Nov.-Dec. 2022, doi: 10.1109/TSC.2021.3090173. 
#Y. Lin, B. Kemme, M. Patino-Martinez and R. Jimenez-Peris, "Enhancing Edge Computing with Database Replication," 2007 26th IEEE International Symposium on Reliable Distributed Systems (SRDS 2007), Beijing, China, 2007, pp. 45-54, doi: 10.1109/SRDS.2007.10.
# E. Chandra and A. I. Kistijantoro, "Database development supporting offline update using CRDT: (Conflict-free replicated data types)," 2017 International Conference on Advanced Informatics, Concepts, Theory, and Applications (ICAICTA), Denpasar, Indonesia, 2017, pp. 1-6, doi: 10.1109/ICAICTA.2017.8090961.
# S. SM, A. Bhadauria, K. Nandy and S. Upadhyay, "Lightweight Data Storage and Caching Solution for MQTT Broker on Edge - A Case Study with SQLite and Redis," 2024 IEEE 21st International Conference on Software Architecture Companion (ICSA-C), Hyderabad, India, 2024, pp. 368-372, doi: 10.1109/ICSA-C63560.2024.00066.
# DataBank, "Securing the Edge: Addressing Edge Computing Security Challenges," DataBank Blog, [Online]. Available: https://www.databank.com/resources/blogs/securing-the-edge-addressing-edge-computing-security-challenges/ (Accessed: April 8, 2025)
#Explo, "Top 8 Embedded SQL Databases in 2025," Explo Blog, 2025, [Online]. Available: https://www.explo.co/blog/embedded-sql-databases.
#TechTarget, "How edge object storage aids distributed computing," TechTarget, 2021, [Online]. Available: https://www.techtarget.com/searchstorage/feature/How-edge-object-storage-aids-distributed-computing.
#Dong et al., "Evolution of Development Priorities in Key-value Stores Serving Large-Scale Applications," FAST '21, 2021, [Online]. Available: https://www.usenix.org/system/files/fast21-dong.pdf.