zhu difeng - Fotolia
Sometimes popular associations between a problem and its fix can lead tech professionals astray, and one example is the connection between IoT and serverless computing.
It's not that serverless computing doesn't offer advantages to develop some IoT applications, but there's a better strategy. To develop and deploy applications for IoT, containers offer a better fix.
IoT containers simplify IoT application development
Even though container applications deal with complications around state, which is not an issue for VMs, tools such as Kubernetes help deploy and scale containers. Microservices are easily deployed in containers because microservices are, typically, either stateless or don't depend on internal state, which makes containerized microservices a good vehicle to support event-driven applications, like IoT.
Many IoT applications are persistent; they run almost constantly because they're heavily used or their application load and run latency interferes with the application's mission to support IoT elements.
Serverless computing works well for applications with low persistence, but its costs and delays can rapidly rise if usage is high. Containers offer a way to support IoT that remains more predictable and controllable than serverless.
Organizations have moved toward containers as the go-to hosting strategy for applications overall, so most organizations already have container development and deployment commitments in place, with tools selected and practices solidified.
Vendors and providers support IoT containers
Where possible, IoT containers should use standard tools and techniques, including Docker and Kubernetes. Vendors such as HPE, Red Hat and VMware optimize their container products for edge applications. IT admins must review their IoT controller and application resources to ensure they accommodate IoT containers because standard container tools might not directly support IoT implementations.
Organizations can also use specialized provider tools. Some public cloud providers support containerized IoT in conjunction with edge application services and features because of the containers' low overhead and portability.
Containers serve as a bridge between specialized industrial control applications and often run on embedded control OSes and general-purpose edge devices, such as Raspberry Pi. Docker runs on Raspberry Pi, which can open edge computing to AI and other more complex applications not normally supported on embedded control OSes.
Some specialty edge products support containers with even less overhead, which makes them suitable for nearly all IoT edge use cases:
- io architecture can support containers as small as several thousand bytes, compared to millions of bytes for a typical container. The service also provides library tools to access sensors and controllers. The developer edition supports container-based development and testing on standard Docker platforms.
- Balena offers specific tools to deploy containers on IoT edge devices with a very limited resource set. It also provides a stripped-down Linux distribution for many devices.
- Kontena provides a cloud-compatible small-scale container for IoT, specializing in large-scale deployments.
Tips to implement IoT containers
IoT experts must review IoT container options with development in mind, particularly how IoT might affect continuous integration/continuous delivery (CI/CD) practices. IoT applications start with development, testing and integration and often pose a challenge even in early phases, because they're designed to run on specialized edge resources, rather than on generalized servers. Organizations can run IoT containers on general-purpose servers or in the cloud and then later move them to edge systems because containers abstract the hardware and software framework.
The most important step to optimize IoT container use is to develop multi-architecture container images, which are containerized development tools that let general software -- when combined with platform-specific libraries -- drive deployments on a wide variety of hardware and OS combinations.
This is where the container's role as a lightweight abstract host is most valuable, but it's still important that engineers build IoT applications with a platform that supports multi-architecture development and deployment. The platform must eliminate specialization in the application and the CI/CD pipeline for development and testing.
Moby BuildKit and Quick Emulator tools facilitate multi-architecture container images. When combined with a generalized container framework like Docker and proper use of Git repositories and CI/CD pipelines, these tools can provide a development team with easy container testing and deployment over almost any common IoT platform, edge or cloud.
It's important to remember with this approach that it's easy to break a multi-architecture model and incorporate unsupported libraries if admins add new platforms without checking compatibility with current libraries.
The final point organizations must remember is that some IoT applications are so specialized in their controller and edge requirements that platform portability and even CI/CD application changes aren't factors. They must ensure the organization really needs an agile IoT edge before committing to a container approach.