In our second blog, we talked about IoT systems and where application performance monitoring can present itself as an important enabler. That topic included monitoring the IoT apps, code and APIs. In this blog, we'll discuss the applicability of container technologies such as Docker in supporting IoT projects and how application monitoring must evolve.
In so many ways containers are ideally suited for building types of applications that can end up running on a variety of devices (many of which will be resource constrained). In particular, the following characteristics can be considered especially beneficial in an IoT development context:
Fast and Easy Deployment – wrapping all software into a filesystem that includes everything needed to run makes containers very portable. This means apps and code can be quickly and efficiently deployed across a variety of IoT devices. Docker images are also lightweight, which facilitates faster spin-up, activation and IoT application deployment -- especially when used in conjunction with orchestration tools such as Kubenetes. Containers simplify large IoT deployments because an image can be changed once and then replaced en-masse. Additionally, infrastructure abstractions mean an application can be used across more IoT environments.
Microservice Development – containers provide an excellent foundation for building smaller independent application services. With respect to IoT, smaller microservices will be more appropriate than larger, resource-intensive monolithic applications. Additional benefits include:
■ Scalability – microservice architectures support horizontal scaling, meaning IoT resource needs can be quickly fulfilled via cloud services.
■ Polyglot languages – each microservice can be developed in a language most optimized for a particular IoT use-case. This could include: C, C++, Node.js (discussed in our previous blog) or Python. Microservice communication can be agnostic too, with both web APIs and lightweight message brokers such as MQTT.
■ Modularity – containerized microservices allow organizations to modularize applications at a very granular level. Services may be designed for specialized IoT communication protocols, API gateway services, self-contained device management/recovery, authentication and security etc.
Hybrid/Multi-Cloud Deployment – as mentioned, containers promote application portability. This means organizations can quickly develop an IoT application locally and deploy at scale on a variety of public cloud platforms. This can include: Docker Cloud, Amazon's EC2 Container service and Google's Container engine – to name just a few.
Continuous Integration, Testing and Delivery – Docker containers are well suited to situations where code needs to developed, tested and deployed in shorter cycles. In many IoT use-cases, code will need to be deployed quickly, so tools that integrate with Docker to speed software builds, testing and releases will be beneficial. Docker for example integrates with GitHub and Jenkins so that new build images are automatically added to the Docker registry and immediately available for deployment.
Containerized IoT Application Tradeoff – Increased Complexity
Without doubt containers provide a great platform to address many IoT development and deployment challenges. That said, the highly-dynamic and interconnected nature of these environments introduce a myriad of new monitoring challenges beyond the scope of traditional tools. Specifically, modern APM tools will provide the following essential capabilities:
Agentless Approaches – instrumenting at the application level will carry too much overhead, especially for small / lightweight IoT microservices. Newer approaches combine low-overhead container discovery, flow-mapping and service monitoring with deeper application level instrumentation when needed. For example, during IoT application testing to pinpoint performance issues that could have catastrophic impacts on a wide-scale deployment (e.g. memory leak draining battery life across 1000's of devices).
Analytics and Machine Learning– monitoring tools must be upgraded to manage the exponential increase in data (volume and variety). IoT devices will be constantly streaming information to large scale data stores for analysis, so any failure conditions and resource utilization problems must be quickly identified. Traditionally this has been handled by manual performance thresholding and lengthy problem triage, but IoT environments necessitate analytical methods to predict complex conditions and anomalies and automate triage workflows.
Continuous Application Monitoring – the use of containers in conjunction with continuous integration, testing and delivery also presents an opportunity to establish monitoring much earlier in the IoT application development lifecycle. Perhaps more than any other applications, IoT applications will incur a bigger business penalty when performance issues are only discovered after deployment (e.g. performance impacting physical device operations and consumer safety).
It's critical therefore that modern APM tools integrate seamlessly with DevOps toolchain processes to ensure IoT application resilience, supportability and recoverability is established across the application lifecycle. This could include incorporating monitoring within the aforementioned GitHub/ Jenkins/ Docker process to check IoT application performance build-upon-build. This type of valuable IoT performance monitoring service that could be extended further when integrated with massively scalable load-testing frameworks.
Connectivity and Communication – regardless of front-end device types and back-end data stores, many IoT applications will demand high-speed connectivity and communication. Monitoring tools must now be capable of predicting and detecting failure conditions across a plethora microservices communicating asynchronously via APIs. More modern APM solutions will provide clear visibility for IoT services traversing many elements (device and API to backend processes), while distilling critical information flows and significant IoT service conditions from irrelevant noise and false-alarms.
The real potential of IoT can only be realized when we fully exploit modern technologies such as Docker containers. Lightweight, fast and portable, containers are well matched to IoT requirements and could become a key enabler. Providing of course that tradeoffs in application complexity are handled by modern approaches and a new model for APM.