By: Jim Azar, Sr. Vice President, CTO
Containers are the new pieces of modern IT estate. They are the building blocks of cloud-native applications. Containers are both cost-effective and easier to construct than virtual machines. They represent a new, better, and leaner world of micro-engineered IT. The container market is growing at a brisk pace.
- Worldwide container management is all set to rise from $465.8 M in 2020 to reach $944 M in 2024 (Gartner).
- Adoption of Kubernetes went up 48 percent in 2019 compared to 27 percent in the previous year (State of Kubernetes 2020 Report).
- The use of containers in production has increased by 300 percent since 2016. It was also observed that 82 percent use CI/CD pipelines in production, 30 percent use serverless technologies in production, 27 percent use a service mesh in production. 55 percent use stateful applications in containers in production (Cloud Native Computing Foundation (CNCF) Cloud-Native Survey 2020).
Containerization is clearly on the rise. A developer can store the individual logic so that the application can be built and run abstractly with no dependencies or constraints on the host environment’s hardware and software. They are images that help to combine what is needed – like a runtime environment – with shared resources for an application. This helps to deploy modern applications in an agile and fast manner.
Monitoring them – not so easy
But containers need to be monitored consistently to leverage this agility and speed. Here’s why it matters.
- It needs service-oriented monitoring with a new lens and high level of observability in the environment from the very onset.
- It requires good visibility into logs, metrics, and applications across various events and tags.
- It needs a significant shift away from traditional monitoring approaches and tools.
- This necessitates a granular slicing that goes right up to the pieces of container-level observability.
- One also needs the right Continuous Integration (CI) tools and APM (Application Performance Monitoring) elements to weave in containers in the spectrum.
- One would have to focus on root-level diagnosis for picking problems at the primary level and addressing them.
- Containers can change frequently which can make visibility difficult.
- Enterprises need to expand and upgrade the skills required for this new frontier of monitoring and management.
- Since containers can be restarted anytime and are temporary, this adds more complexity to monitoring them.
- Every container can run in its sandbox, which complicates their monitoring even further.
- Monitoring containers at scale can add handicaps and delays in the overall system.
- Most enterprises forget or cannot integrate individual pieces with overall monitoring frameworks.
- The lightweight nature and reproducibility factor of containers make them a little hard to monitor.
It’s a daily beast – how to tame it?
As the CNCF survey also shows, complexity has emerged as one of the top challenges in using and deploying containers. Lack of training and monitoring came up as key challenges faced by users. CNCF’s Observability check in the 2nd End User Technology Radar also shows that half of the companies surveyed use five or more tools, and a third had experience with over ten tools. It also found that the most popular observability tools are open source.
According to the Cloud Native Survey, 95 percent of respondents use monitoring, 95 percent use logging, and 74 percent use tracing – which reminds us that there can be overlap and confusion among all three aspects.
The solution to these challenges is to opt for modern-day mindsets and concepts like DevOps and DevSecOps in a shift-left approach. Reliance on traditional monitoring concepts and tools can prove redundant and ineffective here. One can opt for the proper orchestration and monitoring tools designed, especially for such architectures – having a suitable set of aggregation systems that cover logs, metrics, alerts, visualization, and distributed tracing – that will help too. Approach the problem from the angle of layers – like the networking layer. Also, be sure of the tools and approach when a container is being used for a small workload vis-à-vis a situation where it is being used to optimize virtual machines.
Overall, container monitoring should provide visibility of application and resource metrics per container and the aggregated resource usage at the image level. This approach can change short-lived containers.
But working in a world of web-based applications where lightweight components and microservices are norms rather than exceptions makes it essential to have an excellent view of applications both from inside and outside the containers. So, embrace these best practices by all means, but make sure you do not neglect monitoring areas.