Eclipse Ankaios Enables Management of Complexity in Software-Defined Vehicles

The automotive world has changed. Once upon a time, the idea of updating your telephone would have sounded absurd, but now our smartphones constantly get additional features via new applications and software updates. The same is becoming increasingly true for vehicles and is part of what’s driving the software-defined vehicle trend. 

But managing this trend with currently available technologies is a significant challenge. Particularly in the cloud native landscape, containerization and orchestration are dominant. Orchestration makes it much easier to manage the complexities associated with rolling out new features or updating existing ones, particularly as advanced technologies are developed to enhance the vehicle’s functionality. 

However, cloud native orchestrators such as Kubernetes are developed for large, distributed systems spanning over hundreds of nodes and having significant computational power. Even embedded derivates of Kubernetes use as much as 400 megabytes of RAM and use 30% of one core of a Raspberry Pi 4 just in idle mode. Vehicles have very strict requirements, including real-time responsiveness, safety requirements, and extremely tight start-up times. This all must be accomplished with very little computational power dictated by the per-unit fix cost optimizations. 

Eclipse Ankaios targets exactly these problems by following cloud native concepts while focusing on the needs of the automotive sector — being fast, reliable, and low-profile. Another key factor for the fast advances of the cloud native world is the open collaboration. Following this approach, Ankaios is free and open source and is published and developed within the Software Defined Vehicle Working Group at the Eclipse Foundation.

An In-Vehicle ECU-Cluster

Eclipse Ankaios is a workload orchestrator written from scratch in Rust that can be deployed on multiple machines, be they physical or virtual. The cluster is formed by one server and multiple agents — one agent per node on which workloads will be started. 

The single server is one feature that differentiates Ankaios from other cloud native orchestrators. Network segmentations inside the vehicle are not common and are handled differently, so consistency is more important here (remember the CAP theorem). Keeping Ankaios free of unnecessary components for the use-case leader elections and consensus algorithms helps us maintain the performance and the low profile.

Ankaios gives workloads the ability to update the cluster state, enabling creation of operators that dynamically manage the cluster and do the actual orchestration as required by the specific use case. To make things clearer by an example, imagine a health management application that monitors the vehicle state and ensures all required applications are running.

One other neat thing about this capability is that it enables you to write a fleet connector application, allowing you to coordinate the software of an entire fleet of vehicles. This has obvious applications in both the consumer and commercial vehicle spaces. 

Breaking Complexity

Managing complex applications composed of multiple executables, which are sometimes even distributed on multiple machines, was always tedious. Ankaios helps simplify this task by automatically managing dependencies between workloads and providing a single API to change the state of the cluster. 

Dependency management especially is getting particularly important when keeping an eye on the increase of new functionalities in modern vehicles. Applications need to acquire data from, or communicate with, multiple other applications. Combined with hard timing requirements, a reliable and deterministic start-up sequence kept throughout a cluster of ECUs is a must.

To keep the complexity low while configuring and developing using Ankaios, it gives you visibility and access to every partition from one interface. While workloads communicate with their agent to interact with the complete cluster, developers can communicate with the server using the Ankaios CLI or directly using the same API. 

Another important thing about Ankaios is that it is implemented in Rust. The advantage of Rust is it ensures very reliable code by enforcing memory safety. This not only improves cybersecurity but also makes the product more reliable by reducing the number of vulnerabilities and bugs. Possible problems are prevented already during development and not at runtime, which is crucial in the automotive space. 

Flexibility Is a Key Factor

It’s also important to mention that Ankaios doesn’t just support containers: it also enables pluggable runtimes. The reality is that the OEM landscape is quite diverse when it comes to software. While it would be much easier if there was a one-size-fits-all option, it’s not realistic.

We made Ankaios flexible so OEMs can use their favorite runtimes. Support for containers and Kubernetes manifests is already provided via the Podman container engine, but Ankaios is designed to be easily extensible to other runtimes as well. This is enabled by writing a new runtime connector that receives commands from an Ankaios agent and carries them out by instrumenting the desired runtime. 

The communication inside a vehicle is also something that OEMs need to tightly control. The Ankaios server and agents are communicating over an exchangeable communication middleware. The default implementation is using gRPC, which can be easily switched to SOME/IP or DDS if required.

Finally, it’s crucial to note that Ankaios’ flexibility is not just with respect to existing technologies but future ones as well. Technology is evolving quickly: Web Assembly, for example, wasn’t very popular five years ago but now it’s everywhere. Ankaios is built with the flexibility to adopt not just a variety of existing runtimes and container technologies but also new ones as they emerge. 

Ankaios Is Ready to Develop Both Code and Community

The Ankaios project had its initial code contribution on September 6, so there’s a workable version out there. The Ankaios website includes a tutorial on how to install and use the orchestrator and is the best place to start. 

Additionally, you can sign up for our mailing list to keep up to date with news and updates. And if you check out our GitHub repository, you’ll notice that there’s been a lot of progress for Ankaios: there are new features being developed and new releases planned. As next steps, we’re looking to enhance our built-in security and incorporate support for more runtimes and technologies. In other words, there’s no better time than now to get involved!