Publication date: 2020-06-06
A lot is happening in technology: Virtualization (KVM, OpenStack, etc.), containerization (Docker, Kubernetes, etc.), increased level of automation (Saltstack, Ansible, Terraform, and many more) providing the path to continuous integration and deployment enabling more agile ways of software development, overlay networks and software-defined networking, better monitoring and tracing (Prometheus, Jaeger) - just to mention a few. Some of these concepts needed to evolve and mature due to upcoming needs. For instance, without proper automation and troubleshooting tools, it would just not be possible to manage a herd of containers that is needed for microservices.
We do all this to reduce cost, decrease time-to-market, and enable our business to serve customers better than before (better quality, more flexibility to build fancy products, etc.).
But we're not done: let's make the game more dynamic. What about elastic infrastructure that scales up and down following current demand? Of course we need new kinds of self-configuration, self-registration for this, e.g. in monitoring. And how about making nanoservices out of microservices to push toward the next level (like little, decoupled pieces of code executed "serverless")? All this becomes difficult to manage and oversee. Did you properly consider what happens if one of your microservices/nanoservices is not available due to infrastructure outage? Or what happens if some microservices/nanoservice is overloaded resulting in increased response times? And as the complexity is growing, we need to keep on adding and improving tooling to manage this complexity. Due to the immense number of parts and knobs and the automatic reconfigurations and changes taking place, this can't be managed by people alone. So let Artificial Intelligence alias AI do it. That sounds good on vendor slides anyway... And use AI and other automatisms to turn the knobs to make the infrastructure self-optimizing is the next logical advancement. Topics like security and licensing matter, too. More tooling is needed to check whether all parts and pieces are compliant and that helps triggering the proper actions if not.
Currently it looks like complexity is increasing faster than better tooling is able to compensate on. Try to troubleshoot sporadic performance issues in such a complex, constantly changing environment. Then you know what I mean. The term "self-healing" is shaped and wished for for quite some time, but there's still no meta self-troubleshooting in practice.
Don't get me wrong. The new capabilities like elasticity of infrastructure are powerful tools. Applied in a right, fitting context (a big online shop in peak times like "Black Friday" is a widespread example), they can be really helpful and save money below the line. But we should be really careful on the context and whether the benefit added by acting more dynamically and having more "self-x" outweighs the added complexity. Complexity is cost, too.
Looking at cost reduction, decreasing time-to-market, and enabling our business to serve customers better are our original main drivers: How would it be if we stopped the spiral of complexity and favored simplicity over complexity? This means, what if we avoided an unnecessarily high number of "moving parts" and the complexity of highly dynamic operation? But still making use of relevant concepts (automation tooling...) and applying the better tooling (build for handling complex infrastructure) to this simplified infrastructure? Maybe this is what some clever CIOs will do and be highly successful with.