Edge Computing Products and Frameworks

3.1 Industry Products: AWS as an Example

TODO: Ashwin, Brian

3.2 Open Source Frameworks

Open source software provides transparent, publicly-available source code with lenient licensing that allows anyone to use, extend, or modify the implementation. While open source quality varies, the best projects offer security, reliability, efficiency, and immediate usability for developers.

In edge computing -- where data processing occurs near data generation points like IoT devices or local servers rather than centralized clouds -- open source plays a crucial role. The decentralized nature of edge infrastructure naturally aligns with open source's distributed development model. Open source frameworks provide standardized yet adaptable platforms that work across diverse hardware environments, from resource-constrained microcontrollers to powerful edge servers. This flexibility is essential in edge scenarios where computing resources vary widely and proprietary solutions might impose limitations.

Popular frameworks with valuable features include EdgeX Foundry, KubeEdge, and Akraino. Open source in edge computing encompasses both software implementations and standards operating at different levels. For example, EdgeX focuses on software implementation while Akraino defines communication architectures and blueprints for edge infrastructure. This dual approach addresses the needs of diverse edge environments requiring both standardized interfaces and flexible implementations.

Open source edge computing offers benefits similar to general open source software while presenting unique considerations specific to edge environments.

Open source edge computing frameworks generally fall into two categories:

Architecture and Standards Frameworks: Define blueprints, specifications, and reference architectures ensuring interoperability and standardization across edge deployments, focusing on the "what" and "why."
Implementation Frameworks: Provide actual software, tools, and code that developers can deploy directly in edge environments, focusing on the "how."

This dual approach addresses the needs of diverse edge environments requiring both standardized interfaces and flexible implementations. While specific projects may change or become obsolete, the architectural approaches and implementation patterns they represent will likely persist.

General Open Source Advantages

Transparency, Security and Reliability: Community oversight enables faster discovery and remediation of security vulnerabilities compared to closed-source alternatives. However, this transparency can also reveal potential attack vectors, emphasizing why sound architectural principles matter more than "security through obscurity."
Cost and Time Efficiencies: Developers can focus on writing application code rather than building infrastructure components from scratch. This approach delivers significant savings by allowing quick configuration of existing components and eliminating licensing fees.
Community Collaboration: The collaborative nature of open source creates a powerful ecosystem for problem-solving where researchers, hobbyists, and enterprises all contribute to improving the codebase, often producing innovative solutions that might not emerge in more homogeneous environments.

Edge-Specific Benefits

Interoperability: Edge environments typically feature heterogeneous computing resources. Open source projects excel by offering broad device support and allowing developers to contribute implementations for unsupported hardware, continuously expanding compatibility.
Longevity: Open source reduces the risk of vendor lock-in. Even if projects are abandoned by original developers, the codebase remains available for continued use and potential revival, providing confidence for long-term deployments in edge environments.
Accelerated Evolution: The open source model's emphasis on contribution serves as a catalyst for development in the rapidly evolving edge computing field, allowing practitioners to collectively address new challenges as they emerge.

Drawbacks of Open Source Systems

Legal and Licensing Complexities: Organizations may face challenges maintaining compliance with licensing requirements and risk accidentally publishing proprietary code when integrating with open source components.
Limited Driver Support: Many edge devices require proprietary drivers that open source projects cannot include due to licensing restrictions, potentially forcing companies toward proprietary solutions despite preferences otherwise.
Maintenance Variability: Support varies dramatically between projects, with some receiving minimal updates. Unlike commercial offerings, support isn't guaranteed unless paid services are arranged, and project priorities may diverge from organizational needs.

Open source offers significant advantages for edge computing but isn't always the optimal choice. Decision-makers must critically evaluate options against specific use cases, weighing benefits and drawbacks. This requires understanding available options, as open source projects vary widely in design philosophy and quality. For anyone implementing edge computing applications, knowledge of major frameworks and standards is essential.

By carefully evaluating these factors, organizations can select frameworks that balance standardization and implementation support for their specific edge computing needs. There is no universal solution -- organizations should thoroughly define their requirements before evaluating frameworks.

This section will focus on three main frameworks: Akraino, KubeEdge, and EdgeX Foundry, but there are many open source projects, including:

Eclipse ioFog: Offers lightweight edge computing with strong container orchestration for resource-constrained environments. Well-suited for distributed edge deployments where central management must coordinate numerous nodes across disparate locations.
Apache NiFi: Though not exclusively for edge computing, provides powerful tools for routing, transforming, and processing data streams at the edge. Its visual interface enables rapid development of data pipelines by developers with varying expertise levels.
Microsoft Azure IoT Edge: A hybrid approach with open-source edge runtime components and proprietary cloud management.
OpenYurt: Extends Kubernetes to edge scenarios with focus on managing nodes with unstable network connections.
Eclipse Kura: Java-based framework for IoT gateways with access to low-level hardware interfaces.
Baetyl (OpenEdge): Offers separate frameworks for cloud and edge components with modular implementation.
StarlingX: Container-based infrastructure optimized for edge deployments addressing unique requirements like fault management and high availability.

EdgeX Foundry

EdgeX Foundry is a comprehensive implementation framework maintained by the Linux Foundation. Originally developed as Dell's "Project Fuse" in 2015 for IoT gateway computation, it became an open source project in 2017, establishing itself as an industrial-grade edge computing solution comparable to Cloud Foundry.

EdgeX employs a microservices architecture with four service layers and two system services, emphasizing interoperability, flexibility, functionality, robustness, performance, and security. This design enables operation across diverse hardware while maintaining deployment adaptability.

The four service layers include:

Core Services: The foundation containing device knowledge, data flows, and configuration. Provides data persistence, command capabilities, device metadata, and registry services. Acts as the central nervous system connecting edge devices to IT systems.
Supporting Services: Handles analytics, scheduling, and data cleanup. Includes rule engines for edge-based actuation, operation schedulers, and notification systems, enhancing local data processing.
Application Services: Manages data extraction, transformation, and transmission to external services like cloud providers. Enables event-driven processing for operations like encoding and compression.
Device Services: Interfaces with physical devices through their native protocols, converting device-specific data to standardized EdgeX formats. Supports MQTT, BACnet, Modbus, and other protocols.

Two system services complement these layers:

Security: Implements secure storage for sensitive information and includes a reverse proxy to restrict access to REST resources.
System Management: Provides centralized control for operations like starting/stopping services, monitoring health, and collecting metrics.

EdgeX has achieved high implementation maturity with regular releases and patches. Its modular design allows component customization, driving adoption across industries, particularly industrial IoT applications requiring device interoperability.

EdgeX addresses resource constraints through flexible deployment models, running as Docker containers with various orchestration methods. The framework includes virtual devices for testing without physical hardware. Its loosely coupled services organized in layers can run on any hardware/OS, supporting both x86 and ARM processors, though this comprehensive architecture requires higher resource demands than lighter frameworks and presents a steeper learning curve for new developers.

Efficiency is enhanced through intelligent command routing and support for data export to cloud environments via configurable exporters, balancing local processing with cloud integration. This approach enables edge-based decision making without cloud connectivity, though the microservices approach may introduce some latency compared to more tightly integrated solutions.

Developers primarily interact with Application ("north side") and Device ("south side") service layers, using specialized SDKs that handle interconnection boilerplate, allowing focus on application code. While this simplifies development, optimal deployment typically requires containerization expertise, and configuration may require significant optimization effort.

EdgeX Foundry excels in diverse scenarios including industrial IoT (factory equipment monitoring across protocols), building automation (unified management of systems), retail environments (processing point-of-sale data), energy management (usage monitoring and optimization), smart cities (local processing of urban infrastructure data), and medical device integration (standardizing healthcare device data).

The framework offers significant advantages through its vendor neutrality (community-maintained to avoid lock-in), interoperability (bridging protocols, hardware platforms, and cloud systems), modularity (independent component customization), and deployment flexibility (supporting containers, pods, or binaries). An active community ensures ongoing development and regular releases, while ready-to-use components support customization options. The system maintains operation during network outages with data buffering, though documentation may not cover all integration scenarios.

KubeEdge

KubeEdge is an open-source edge computing platform that extends Kubernetes containerized application orchestration to edge nodes. Originally created by Huawei and donated to the Cloud Native Computing Foundation (CNCF) in 2019, it has gained significant traction among organizations already using Kubernetes. It’s ideal use cases are in smart manufacturing, smart city applications, and edge machine learning inference.

KubeEdge's architecture consists of two primary components:

Cloud Part: Includes KubeEdge CloudCore and the Kubernetes API server, managing node and pod metadata, making deployment decisions, and publishing them to edge nodes. It provides unified management through standard Kubernetes interfaces.
Edge Part: Consists of EdgeCore running directly on edge devices, managing containerized applications, synchronizing with the cloud, and operating autonomously during disconnections. It handles computing workloads, network operations, device twin management, and message routing.

KubeEdge maintains compatibility with Kubernetes primitives while introducing edge-specific optimizations, enabling consistent deployment practices across infrastructure. It features a lightweight footprint optimized for edge devices, consuming significantly less resources than standard Kubernetes nodes while preserving functionality. Edge nodes function independently during cloud disconnections through local data storage and processing, resynchronizing when connectivity returns. The framework provides comprehensive API and controller for managing IoT devices connected to edge nodes, making it valuable for deployments with numerous heterogeneous devices. Security is implemented through certificate-based authentication between components and TLS encryption for data in transit, protecting distributed edge infrastructure. KubeEdge processes data locally and transmits only relevant information to the cloud, improving response times for time-sensitive operations.

Despite its advantages, KubeEdge comes with several limitations to consider. It requires knowledge of Kubernetes concepts, presenting a learning curve for teams without prior experience with container orchestration. The framework also needs an existing Kubernetes control plane, which adds infrastructure requirements. While more lightweight than standard Kubernetes, KubeEdge demands more resources than some alternative edge frameworks, potentially making it unsuitable for highly constrained devices. Its comprehensive feature set may be overly complex for simple edge deployments where a more streamlined solution would suffice. Additionally, as a relatively young project compared to some alternatives, its ecosystem and tooling continue to evolve, which may impact long-term stability and support options.

Open Source Standards

While previous sections focused on software implementation frameworks, open standards maintained by communities like the Linux Foundation are equally important. These standards define system and architectural-level details at a higher abstraction layer than software implementation.

One such standard isMulti-Access Edge Computing (MEC), a network architecture that positions computing resources closer to end users, typically within or adjacent to cellular base stations and access points, primarily to reduce latency through localized processing.

The European Telecommunications Standards Institute (ETSI) established MEC in 2014 to support emerging edge technology development. Frameworks like KubeEdge and EdgeX Foundry operate within the MEC paradigm but focus on application deployment rather than modifying underlying network architecture -- they leverage existing infrastructure without fundamentally altering it.

Several open source initiatives support MEC implementations:

Open Network Automation Platform (ONAP): A Linux Foundation platform for orchestrating network functions, including edge computing resources, enabling telecom providers to automate service management.
O-RAN Alliance: Promotes openness in radio access networks, supporting edge computing through open interfaces and virtualized network elements.
OpenAirInterface (OAI): Provides standardized implementation of 4G/5G networks, enabling experimental deployments on commodity hardware.

These projects address different aspects of the telecommunications stack, creating flexible edge computing deployments that reduce dependence on proprietary implementations.

Research suggests future 6G networks will require more flexible MEC architectures based on network function disaggregation and dynamic reconfiguration. Open interfaces will be critical for enabling multi-vendor deployments, while standardized APIs will facilitate ecosystem development around MEC platforms.

The advancement of open source MEC solutions promises to accelerate innovation by broadening developer contributions to telecommunications edge computing, potentially reducing costs while increasing flexibility and adoption.

Akraino

Akraino Edge Stack takes a distinct approach to open source edge computing by focusing on architectural blueprints rather than specific software implementations. Launched in 2018 under the Linux Foundation with AT&T's initial contribution, it quickly attracted industry partners including Nokia, Intel, Arm, and Ericsson.

The core concept in Akraino is the "blueprint" -- a validated configuration of hardware and software components designed for specific edge computing use cases. Blueprints include hardware specifications, software components, and deployment instructions tailored to particular scenarios. This approach represents a middle ground between rigid standardization and custom implementations, providing guidance without mandating vendor-specific solutions. Akraino's development process progresses from proposal through validation. New blueprints begin as proposals outlining use cases and requirements, advance to development where components are integrated, and undergo extensive testing before release to verify functionality, performance, and security. This rigorous validation ensures blueprints represent production-ready architectural patterns.

While designed to support any access methodology, Akraino is primarily used in telecommunications (4G LTE and 5G), with placement of edge devices based on specific requirements.

Akraimo attempts to minimize total cost of operation (TCO) by optimizing the placement of edges devices within the network but also with strong consideration for performance requirements.

Akraino offers distinct advantages through its architectural focus: validated configurations reduce implementation risk, specific use case targeting balances standardization with flexibility, and rigorous testing ensures production readiness. However, limitations exist compared to implementation frameworks: blueprints require significant work to become functional systems, demand substantial technical expertise, may specify hardware configurations limiting flexibility, and vary in maturity.

Akraino complements implementation frameworks like EdgeX Foundry and KubeEdge in the open source edge computing ecosystem. While these provide deployable software components, Akraino offers architectural guidance for integrating them into cohesive systems. As edge computing matures, Akraino's approach will likely play an increasingly important role in standardizing architectures while enabling innovation.

3.3 Serverless at the Edge

TODO: Jasmine