In recent years, the popularity of containers has grown among developers, particularly within a testing environment as an enabling part of a DevOps pipeline. This is largely due to them being easier to work with than the alternatives thanks to increased efficiency and speed of deployment.
A study by Forrester found that 66% of organisations that adopted containers experienced accelerated developer efficiency, while 75% achieved a moderate to significant increase in application deployment speed. As such, for developers, they have become integral to simplifying the development cycle, resulting in more widespread adoption.
While containers offer an effective way to recompile code and test in a lightweight and rapid manner, the container landscape could be transforming…
Why are containers so popular?
There has long been support for using a container-based approach as a runtime unit. But, it’s the emergence of cloud-based providers, such as Amazon Web Services, that has led to containers being used to deploy code for live production applications becoming the preferred way to do things. Faced with stiffer competition, companies have needed to become more agile in their software development. Gone are the days of long production cycles! Instead, they have begun to be replaced by a develop-on-the-fly approach, DevOps, that allows for much shorter innovation cycles.
Containers are popular for a number of reasons, not least that they make it easier to implement an agile approach to building, testing and deploying software. This is due to this approach isolating runtime components, allowing developers to drop in a new version of the code, immediately test it and see if it is correct, therefore simplifying the development cycle. This is significantly easier and far less time-consuming than the previous method of installing the code to be tested onto virtual machines or native OS, which also required installing software. Ultimately, containers offer a more agile and responsive framework and mean that developers don’t have to go through a long build and deployment cycle.
Additionally, a container-based approach offers developers integration with mature and mainstream tools that are integrated into the development, production and monitoring technologies that are now available.
Limitations of containers
Fortunately, many of the disadvantages of using containers have largely been or are in the process of being overcome. For instance, running Docker on Windows historically isn’t a comfortable fit, but this is something we know Microsoft is working hard to overcome, and in the imminent future it should no longer be an issue.
The more common problem facing the use of containers is, in fact, the number of people in the market who don’t understand what a container is and what the benefits are of the encapsulation of code and the runtime environment which allow it to operate. Quite often, these people are stuck in a native operating system mindset and have yet to grasp the capabilities and potential of containers. In these cases, a paradigm shift still needs to occur; however, we are seeing the market begin to get over this stumbling block.
Ultimately, whether you use containers comes down to underlying architecture and the non-functional requirements you need to meet with your deployment. For instance, if a developer wants massive horizontal scaling by spinning up on-demand resources within a major cloud environment then deploying via containers makes sense.
Yet, if the user is running an enterprise application on dedicated hardware in a highly controlled environment, and it’s mission-critical to have a sub-second response time, for example, containers may not be the best option.
What’s next for containers?
In the future, we will continue to see a shift to a container-based approach as people buy software as a service and providers behind the scenes start deploying containers in order to roll out an upgrade within seconds and with minimal disruption to service.
Currently, there are no apparent successors to containers. However, in an increasingly cloud-heavy environment, there seems to be a trend for cloud-native applications that are composed of discrete functional units that are capable of being run independently, behaving like micro-containers and supported by the cloud environment. But with such a strong case for the use of containers, it is likely containers will long be the preferred approach for developers, allowing them to deploy software quickly and efficiently and in a manner that reduces the tie-in to specific cloud vendors.