Orchestration and mobility in a containerized world
We all know the story on Containers, and how simple they make things. Now we can achieve true Infrastructure as Code and embark on a Microservices journey that’s sustained on appropriate technology. Essentially, containers open the door that allows development methods to become real without a lot of effort (well, you do have to rewrite applications, but that is not the topic here.) But the good thing about containers may be the worst thing about containers — they’re very easy to start deploying. And suddenly you’re caught in a lack of control nightmare, and that’s where Orchestration helps.
The orchestration layer will bring additional control to the way your containers are deployed, making it possible to scale and develop truly resilient, secure and scalable applications, with lots of automation and monitoring features included. And you can develop across multiple locations, on premises and on several cloud providers. IBM Cloud supports the full scope of these technologies, and makes it possible to use them in an integrated fashion with hundreds of other components.
Well, not quite. In the vast majority of use cases, you create completely new workloads, very modular, decoupled and sometimes in a way that would not be possible without container technology. The point is, the approach to building applications needs to drastically change. Features that were expected of the infrastructure can be built at application level — monitoring, logging, resiliency, security and scalability just to name a few. The development cycles and process must be different and the functional design will have a lot more requirements, but on the positive side we can build applications that are really infrastructure independent. In addition to that, you can always rely on a provider to manage and enhance the infrastructure side.
Once an application is designed and deployed following DevOps concepts and a decoupled Microservices topology, it can run anywhere, provided the used runtime is available (Docker, for example). The application can be written in a way that all components can run on a single site (on or off premises), distributed across multiple sites or even across providers. Again, orchestration is the key to keeping track of all this.
Consider a fully resilient, microservices based solution for a global bank’s online frontend — an always-on solution and the ability to host the application almost anywhere is critical. The development, quality and production environments are dispersed throughout the globe, allowing easy and latency free access to data systems when and where needed. Also, due to a fully decoupled application design, the application runs on more than 400 containers, so it would be unmanageable without the orchestration layer.
IBM worked with this client to support every aspect of development and deployment, including security controls, certifications, penetration and stress tests. The solution is fully resilient and there are regular disaster recovery tests that verify everything is running as designed.
Containers are a true enabler for agile development and decoupling. DevOps can be applied to other technologies and legacy infrastructure, but containers were built to deliver this kind of solution. We need a change in mindset to explore the full potential of these technologies. Ready to talk to an IBM expert? Schedule a consultation here.
Follow me on Twitter for updates on this topic.