[Editor's Note] We spoke to Adam Taylor of Mouser Electronics about how container technology is transforming embedded software development.


Embedded software development is unique because each project has different hardware configurations and interfaces.

However, containerization allows developers to more easily leverage software libraries and functions, especially in designs that use common microprocessors or microprocessors of the same family.

Containerization has become increasingly popular in the cloud space in recent years and is becoming a useful approach for application development and deployment across the technology industry.

This article explores the benefits of containerization and how it is transforming the way applications and embedded software are developed.

■ Advantages of Containerization

Containerization is a form of virtualization.

The most common form of virtualization is a virtual machine, which emulates an entire computer, including the operating system.

Virtual machines allow developers to use software-based computers that run multiple applications and operating systems on a single physical computer.

For example, an FPGA engineer can develop embedded Linux solutions using a Linux virtual machine within a Windows development environment, which requires compilation in a Linux environment.

Using a virtual machine eliminates the need for a separate development computer.

However, in some cases, developers may not need to virtualize the entire physical machine and operating system, and may only want to run a single application and its required libraries and dependencies.

In these cases, embedded containers act as a virtualization layer that isolates the application from the underlying operating system while including all the dependencies it needs to run.

These containers allow you to deploy applications in a much lighter and more efficient way than full virtual machines.

At first, it might seem a bit strange that containers can help with embedded software development.

Because embedded software is much more closely linked to hardware.

However, there are also useful use cases for containers in embedded software development.

The most obvious example is providing a replicated build environment to every developer working on a project.

Ensuring that all developers use the same environment eliminates variability that can arise from subtle differences in library versions, environment settings, or compiler options. Can be.

This is how containers have been used in traditional software development environments, and it offers significant advantages to embedded systems developers, just as it does to cloud and SaaS developers.

One of the main advantages of containers is that they can be deployed directly to embedded systems.

Containers are designed to run in embedded Linux or real-time operating system (RTOS) environments and are deployed on top of those embedded systems.

Embedded containers are often tightly coupled to the hardware and are often written in lower-level languages than traditional container applications.

Embedded systems typically have limited resources and are specialized for specific-purpose applications.

They are also often deployed in challenging environments where unauthorized access or modification is not permitted.

Using containers for embedded applications offers several benefits beyond the more obvious ones, such as consistent deployment of the libraries and resources that support your application.

Among these, the most important advantages are isolation and security resulting from the unique isolation characteristics between applications.

Of course, security breaches or issues can still occur, but the scope of impact is generally limited to within that container.

Additionally, leveraging embedded containers allows you to leverage the benefits of a microservices architecture.

Microservices architecture breaks complex applications into small, manageable units called services, enabling parallel development and easier testing through communication between containers using defined interfaces (e.g., ports, Docker networks).

A container-based approach is on-siteIt is also beneficial in solving the difficulties of updating or modifying work carried out in .

Because you can easily deploy containers through network-based or cloud-based services such as Docker Hub, AWS, Harbor, and Azure.

For example, you can deploy updated containers to embedded devices and install them safely and at the appropriate time on the system.

Deploying containers in embedded environments should be part of a company's DevSecOps environment, encompassing development, security, and operations, to ensure consistency and secure, effective deployment.

This is especially important for mission-critical end applications.

This container-based approach is also being further standardized through programs such as the Open Container Initiative (OCI).

OCI is an industry-led project that aims to standardize container technology, defining both runtime and image specifications.

This standardization simplifies implementation of support for containers deployed in embedded applications, ensuring that each container is packaged and deployed in a familiar manner.

Leveraging containers in embedded software development requires a nuanced approach.

Embedded systems require customized containerization strategies due to their limited resources, real-time processing requirements, and high hardware dependency.

While tools and platforms supporting containerization in these embedded environments are emerging, integrating them into existing workflows requires careful consideration and coordination.

Of the several approaches briefly introduced in this blog, the most common use case today is using containers to develop embedded software environments. and integrating it with the DevSecOps system.

However, in the future, it is expected that the method of directly deploying software developed in these containerized development environments to actual embedded devices in the form of containers will become increasingly common.

■ Efficient and flexible embedded SW development using containers

As embedded systems become increasingly sophisticated, the introduction of tools that enable consistency, efficiency, and automation is critical.

Appropriate use of containers can make embedded software development more efficient and flexible, while providing a better working experience for developers.

For teams looking to modernize their workflows, container technology is well worth a close look.

※ About the author
Adam Taylor is a professor and engineering leader in embedded systems and a globally recognized expert in FPGA/SoC and electronic design.