We are living in an era of digitization, in which companies are reshaping their operations and innovating their business models by offering next generation connected products and digital services. Machines, consumer goods and vehicles are transforming into complex connected IoT devices with advanced software features, collecting and reacting on user insights and data in real-time. New IoT edge use cases emerge driven by massive amounts of real-time data, the growing complexity of IoT devices, and machine learning’s ability to extract relevance from data. Companies are considering using certain applications at the edge to get more value from their data, handle varied connectivity and data mobility, address the need for real-time decision-making, localized computing power, security and safety. Edge computing is shifting from hardware to software focusing on intelligent devices, edge platforms, edge applications and services. New connected products continuously increase in complexity to benefit AIoT – be it built into the products or empowering the production lines. Building the products of the future such as connected vehicles and in vehicle cross-domain applications, connected appliances, smart buildings and connected manufacturing is becoming more and more complex and companies are losing time and money to build the common technologies by themselves, sometimes even lacking the right skills and expertise.
Eclipse Kanto aims to better solve the challenges of digital transformers on their journey to create their next generation connected products and digital services, starting from the device. Eclipse Kanto addresses the ever growing complexity at the edge with a lightweight device-centric technology incorporating the knowledge and expertise of 20+ years of experience in the field of edge and IoT. Eclipse Kanto aims to selectively bring fitting cloud-native technologies like containerization and K8s control planes at the edge with a lightweight implementation to seamlessly manage diverse software on constrained edge devices like vehicle computers, connected building gateways, connected appliance and equipment, machines and more. By adopting established open concepts for modelling IoT device features, data and state into digital twins Eclipse Kanto will further harmonize the way heterogeneous edge devices and their capabilities are represented and managed. But no one can do it alone!
We believe that open source is where true collaboration, technology co-development and co-innovation can happen! By bringing cohesion in the open source edge, Eclipse Kanto will enable synergies between existing embedded and cloud ecosystems to converge knowledge and technology.
We believe that technology providers, manufacturers, service providers and digital transformers can join forces and together build the common technology to address the sheer complexity of edge software and hardware, thus accelerate value creation with differentiating connected products and digital services. Furthermore, building on open technology and open standards ensures no vendor lock-in and empowers manufacturers with full control and transparency over the software that goes at the heart of their devices.
Eclipse Kanto provides a modular IoT edge software stack for AIoT, configurable and remotely manageable by an IoT cloud ecosystem of choice.
Eclipse Kanto will bring all the essential IoT enablement for edge devices
- Cloud connectivity and digital twins in the cloud via integrations with most fit-for-purpose public IoT platforms like Eclipse IoT packages, Bosch IoT Suite or Microsoft Azure IoT
- Comprehensive semantic representation and modelling of edge functions and state using Eclipse Vorto or alternatives that might better fit specific domains
- Container management using open standards and open specifications like OCI and integrations with open source container management runtimes like contianerd, podman and more depending on domain and hardware requirements
- Local messaging and communication (pub-sub) between devices and applications using MQTT and integrations with open domain-specific protocols or standards.
- Local edge management and configuration including containers, logs, files, runtime metrics, performance monitoring, health status and more depending on the domain specifics
- Flexible software updates for diverse software like containerized applications, device firmware, operating system, scripts, etc. via open software management standards and integrations with best-in-class device and software management public backends like Eclipse hawkBit, Bosch IoT Suite Device Management, Microsoft Azure IoT Device Management and more
- Flexible deployment options and integration with existing Linux ecosystems like Debian, Apertis Pro and Yocto Project
- Integrations with open source complex event processing, analytics & AI systems and frameworks to enable analytics & AI for the lightweight edge
In addition, device-side client SDKs and libraries (southbound) will be provided for Go, Python, Rust to ease development of containerized device applications and software update agents.
Eclipse Kanto is a modular IoT edge software stack for devices that enables them for AIoT with all the essentials - cloud connectivity and digital twins, local messaging, container management and software updates - all configurable and remotely manageable by an IoT cloud ecosystem of choice.
Eclipse Kanto makes it possible to deploy intelligence on the device so companies can get more value from diverse edge assets, process and act on IoT data right on the device and manage devices from the cloud. Device manufacturers can add new revenue streams with connected products and ensure agile development for hardware and software. Using Eclipse Kanto, technology teams take advantage of configurable and reusable building blocks to connect the unconnected or build the edge applications for the next generation connected products and services. Eclipse Kanto is specifically optimized for complex IoT devices facing limited hardware resources, (near) real-time requirements, diverse device software, heterogeneous data sources and the ability to operate without connection. This makes it a perfect technology for emerging paradigms such as software-defined vehicles, connected machines and connected manufacturing, smart appliances, smart buildings and more!
Eclipse Kanto is based on lightweight native components, open protocols and standard containers that ensure availability on hardware, minimum integration work, reduced complexity and scalable applications
- Lightweight – deployable on various constrained edge devices with ranging hardware capabilities to scale hardware and connect diverse edge devices and data sources
- Containerized – develop edge applications using most fit-for-purpose languages and frameworks, manage diverse device software with cloud-native technology in uniform way
- Connected – connect to most-fit-for-purpose public IoT platforms, manage devices and device data from the cloud with minimum customization, and prototype quickly
- Flexible – choose and combine reusable configurable and interoperable building blocks to bring the right IoT edge capabilities depending on the hardware and use case
Eclipse Kanto empowers digital transformers to build connected products and digital services and benefit from
- Accelerated value creation via reducing the sheer complexity of edge software and promoting focus on differentiating device features and rapid innovation
- Accelerated development with quick prototyping, fast migration of cloud-native applications to edge devices
- Advanced interoperability by open standards and common APIs bundled in configurable and reusable building blocks
- Mature and robust technology incorporating knowledge and insights from edge experts with 20+ years in the field of edge and IoT
Eclipse Kanto's features at a glance
- Cloud connectivity via MQTT to the Bosch IoT Suite (powered by Eclipse Hono, Eclipse Ditto and Eclipse hawkBit)
- Automatically and securely connect devices to the Bosch IoT Suite cloud services using MQTT
- Auto-registration of edge devices using certificates
- Use of digital twins in the cloud for connected edge devices and their capabilities
- Send telemetry data and receive commands from the cloud
- Self-reliant and autonomous operation during connectivity loss via buffering messages
- Cloud connectivity via MQTT to Microsoft Azure IoT
- Device provisioning via Azure Device Provisioning Service
- Connection to Azure IoT Hub using connection string and authentication with SAS token
- Support of device-to-cloud (telemetry) and cloud-to-device (command&control) messages
- Comprehensive semantic representation and modelling of edge functions and state
- Represent edge devices and their capabilities using Eclipse Vorto models and function blocks
- Command and control devices in uniform way based on Eclipse Vorto models - locally and from the cloud
- Local communication and messaging via MQTT and Eclipse Ditto
- Develop loosely coupled event-driven applications that exchange messages over a local Mosquito MQTT broker
- MQTT broker configurations and message forwarding between applications and to the cloud
- Access and manage connected IoT devices, IoT device data and services in cloud and at the edge via Eclipse Ditto protocol
- Lightweight and pluggable OCI-compliant container management
- Package edge applications into OCI containers to ensure better isolation, availability, reliability and dependency management
- Use most fit-for-purpose technology and programming frameworks for IoT applications
- Containers lifecycle and state management, incl. restart policy support, host resources access management, networking support, secured download and installation via secured access to container registries
- Configure, monitor and manage OCI containers and containerized applications deployed at the edge using containers digital twin representation based on Vorto models, possibility to use the models in management operations
- Flexible integration with most fit-for-purpose container management runtimes like containerd, podman, kata containers, LXC, LXD and more
- Advanced container management using container manifests to define container engine state
- Ensure a configuration interface that abstracts the complexity of the underlying executable components
- Ensure initial system state, for example initial tooling/applications provisioning
- Perform configurations and management at a higher level (e.g. the configuration unit is a set of containers, not a single instance)
- Lightweight Kubernates control plane to enable distributed edge applications and seamless management of diverse software running on complex edge devices
- Flexible software management
- Deploy and manage software artifacts at the edge using the standard software management model of Bosch IoT Suite
- Out-of-the box support for deployment and updates of OCI containers and containerized applications at the edge, incl. enablement to use mass management operations
- Possibility to easily add support for new types of software artifact using ready SoftwareUpdatable Go library and SoftwareUpdatable features providing extensible and configurable software download and installation flow
- Script-based software updates
- Software update on the device using a script that enables updates of any kind of software, predefined in your script - via the standard software management of the Bosch IoT Suite Device Management using SoftwareUpdatable
- Monitor the install and download process and resume it on start up.
- File upload
- Upload files such as logs, configurations, backups to the cloud using flexible cloud storage integrations with Azure Cloud Storage and AWS S3 buckets
- Configure the edge from the backend to send files periodically, or for the backend to explicitly trigger file upload from the device
- Advanced edge performance monitoring, logging and tracing via OpenTelemetry integration
- Configure and collect CPU usage, memory, IO, disk access and more metrics for the system and per edge application
- Configure logging and tracing levels for the whole system and per edge application in real time to remotely debug and monitor the edge
- Integrate into an ecosystem of systems and tools for visualization, analysis and application performance insights
- Flexible deployment and availability on hardware
- Deployable on wide range of platforms with varying hardware capabilities - Linux ARM, Linux ARM64, Linux x86_64, including ready packages and life cycle management scripts
- Specifically optimized for constrained devices to offer compact footprint, optimal resource utilization and excellent performance
- Integrated with Linux ecosystems like Yocto Project, Debian and Apertis Pro
- Integrated with open hardware platforms like Raspberry Pi
- Robust device-side client SDKs and libraries (southbound) for different languages to accelerate development of edge applications
- Eclipse Ditto libraries for device-side applications (southbound) for integration with the local MQTT messaging using Eclipse Ditto for Go, Python and more
- SoftwareUpdatable library for implementing software update agents in Go
Eclipse Kanto is implemented in Go to naturally integrate with existing cloud-native technologies, frameworks and ecosystems, meet footprint and (near) real-time constraints, leverage modern development toolchains and ensure optimal learning curve for IoT and open source developers! As Eclipse Kanto is modular by nature, new components can also be implemented in other languages like Rust, C/C++ depending on the use cases and problems they solve. Whatever the language, everyone is more than welcome onboard to learn, collaborate and contribute on each and every step on the way forward!
Eclipse Kanto delivers the essential IoT enablement at the edge by bringing cloud-native technology and IoT concepts on the device.
Eclipse IoT is already the happy home for mature IoT projects like Eclipse Hono, Eclipse Ditto, Eclipse Vorto and Eclipse hawkBit that build an open ecosystem bringing collaborative knowledge and best practice on how to model, connect and manage IoT devices, their data and software. Eclipse Kanto adopts key concepts from these IoT projects on the device, like Eclipse Hono cloud connectivity message patterns, modelling edge features and state using Eclipse Vorto, managing and controlling edge devices and features using Eclipse Ditto and more. By bringing Eclipse Kanto in Eclipse IoT we will create cohesion between device and cloud, further enriching and extending the existing ecosystems.
After a successful project review in October 2021, we aim for having the initial contribution cleared and approved by November 2021.
Until end of 2021, we plan to make available and further develop in the open source the edge technology extensions and enhancements for automotive use cases and software-defined vehicles like cloud connectivity to Microsoft Azure IoT, state-driven container management using container manifests to define container engine state, podman integration, advanced edge performance monitoring via OpenTelemetry, edge logs management and more!
A first release is expected to be available end of 2021.
After open sourcing the core IoT edge technology, we plan to contribute edge features and enhancement for automotive use cases and software-defined vehicles, as part of the open technology platform and ecosystem for IoT and software-defined vehicle development we are building. These and more advanced edge features will be further developed in the open source together with additional companies and organizations in the scope of the Software-Defined Vehicle working group to be launched soon:
- Cloud connectivity, communication and device provisioning to Microsoft Azure IoT
- Advanced containers management using container manifests to define container engine state
- Advanced edge performance monitoring, logging and tracing via OpenTelemetry integration
- Lightweight Kubernates control plane to enable seamless management of distributed edge applications
- Podman integration as container management runtime
We will be further consolidating open source edge software and integrating with existing Linux ecosystems via
- Consolidated deployment model and integration with Yocto Project, Debian and Apertis Pro ecosystems
- Consolidated device-side client SDKs and libraries
To further enable developers and contributors in the open source we will continuously invest in extending the CI/CD pipelines, testing environments and user documentation
- Comprehensive integration test environments including virtualization as well as test
- Comprehensive fully-fledged user documentation including more advanced developer guides and tutorials
- Continuous building and deployment of additional deployable artifacts like Debian packages and Yocto metalayers
- Comprehensive integration test environments and continuous integration testing with real hardware