Between SaaS, IaaS and open source software, it’s fast and easy to spin up any one of the myriad solutions that promise to solve a given technology or business problem. The modern development world promises that any code can run anywhere due to seamless interoperability between libraries, frameworks and apps that leverage well-defined and consistent APIs.
Developers, data analysts and infrastructure teams have more tools at their disposal than ever before. Many, however, are overwhelmed by the challenges associated with trying to stitch everything together with a mix of manual and automated processes.
The problem is particularly painful for enterprises. A recent InfoWorld article, Complexity is killing software developers, describes the morass of that enterprises have to wade through:
“The shift from building applications in a monolithic architecture...to breaking them down into multiple microservices, packaged up into containers, orchestrated with Kubernetes, and hosted in a distributed cloud environment, marks a clear jump in the level of complexity of our software.”
There’s even a term for it - cloud complexity - and an accompanying Cloud Complexity Cost Calculator from Deloitte. The Cloud Native Computing Foundation’s (CNCF) landscape of the 1,000 or so services that make up the cloud-native ecosystem is direct evidence of the problem - and these are cloud-native solutions. That doesn’t include the 200+ services offered by each of the big three clouds (AWS, GCP, Azure).
Cloud-Native Doesn’t Have to Be Complex
The false choice here is that choice itself begets complexity. It does not. Developers and architects can choose frameworks and services that are not complex - even if the myriad of choices are. This is the key to reducing complexity - choosing wisely AND choosing cloud native.
One reason is that most cloud-native applications are not inherently complex. Granted, there is a continuum but the inherent complexity of Kubernetes is not rooted in Kubernetes, rather it is mired in the non-cloud native world doing unnatural things with connectors and plugins to try and integrate non-cloud native applications. As we have seen with countless tutorials, even something like object storage as a service can be easy if it is cloud native.
There are certainly reasons to retain legacy infrastructure, we are not suggesting otherwise, but the path forward and the way to reduce complexity is to chart a path to cloud-native implementations of the applications, infrastructure and workflows. At this point most legacy applications can run on cloud platforms, but they fail to take advantage of the scalability, extensibility, interoperability and portability that is provided by cloud-native software. Trying to shoehorn them into a cloud-native architecture by building API support and other extensions as microservices that run on top of them creates needless complexity. Jamming legacy code into a container could be a first step towards achieving the benefits of being cloud-native because then that container could be orchestrated by Kubernetes. However, in the long run you’ll increase complexity as developers struggle to maintain and improve the codebase at the same time they’re managing dependencies.
In contrast, cloud-native applications are built to run as microservices. Each microservice has its own functionality, and microservices communicate via API to form complete applications. Breaking each function down to its core is simplicity in itself. In a microservices-based application, code and its function are almost always more clearly defined and organized than they would be in a massive monolith application.
Cloud-native applications are more than a group of microservices. Containers are an abstraction that provide the operating system and other dependencies to the microservice code that runs within them. The container removes the requirement of maintaining dependencies everywhere the microservice runs. We have now simplified the application and underlying dependencies.
Kubernetes is Key
Kubernetes establishes an infrastructure for providing hardware resources and services to the containers it orchestrates. This simplifies providing services like monitoring, reporting, authentication and encryption to microservices. These services don’t need to be installed individually for every application, and, because the environment is cloud-native and all of its parts are API-driven, applications don’t need to be hand-coded to include these services.
Tips to Combat Software Complexity
The monolith is now a fluid distributed application. The result is that the number of moving parts has increased exponentially. Yet, each moving part has been simplified. At every step, developers need to fight the urge to introduce complexity and instead reward simplicity. Remove dependencies between microservices. Even though manual processes may seem like a brilliant kludge, they must be simplified and replaced with code. Use Kubernetes and its declarative API to manage everything - services, agents, networking, storage - in a consistent way.
Once complexity is minimized and consistency is maximized, you can achieve operational efficiency through automation. Processes that are repeatable and predictable are easily automated to adhere to best practices so applications can scale elastically without runtime surprises. Simplify by ensuring consistent configurations and application design across Kubernetes clusters.
Choose backing object storage that contributes to simplicity. Object storage is a foundational cloud-native technology, but not all solutions are the same. Beware the legacy storage appliance with an added object storage interface - by definition an appliance isn’t consistent and available across multiple platforms. Instead, look to object storage that has been designed and built for cloud-native implementations. MinIO software-defined object storage provides a simple, streamlined, high-performance solution that runs anywhere from bare metal to any Kubernetes distribution to provide a consistent API-driven experience for developers and infrastructure teams.
Simplicity is one of our core values at MinIO. We pursue simplicity and minimalism in everything we do from our product’s design, code, docs, and support to the language and design we use on our website and blog. Our team strives to build software-defined object storage that is the fastest, most scalable and the most widely-implemented S3-compatible storage outside of AWS - and give you easy-to-use tools like MinIO Client (mc) and MinIO Kubernetes Operator to manage it.
Our relentless dedication to simplicity means that cloud architects have a solid foundation of cloud-native object storage upon which they can build, deploy and operate applications. MinIO is a tiny 100 MB binary that runs on anything, anywhere to provide high-performance object storage via a consistent cloud-native and S3-compliant interface. MinIO’s power is deeply intertwined with its simplicity. We’ve built it to run in any cloud, datacenter, developer laptop, specialized edge device, on bare metal or on Kubernetes, and on any combination - including powerful yet easy-to-configure replication that keeps multiple MinIO clusters in-sync automatically.
At first glance, the cloud-native world may appear overly complex to those with an enterprise IT mindset, but the only way cloud-native becomes complex is when we make it that way. Core cloud-native elements are far from complex - they are simple, straightforward, consistent and portable. Cloud architects must rely on minimalistic simplicity to reduce opportunities for errors, improve uptime and achieve elastic scalability across multiple clouds, in the datacenter and at the edge. MinIO delivers all this and more, making it an excellent object storage solution that serves as the foundation for high-performance, reliable and scalable cloud-native architectures. MinIO can be installed and configured within minutes simply by downloading a Docker image or a single binary and then executing it. The amount of configuration options and variations is kept to a minimum, resulting in near-zero system administration tasks and very few paths to failure. Upgrading MinIO is done with a single command which is non-disruptive and incurs zero downtime - lowering total cost of ownership.
Download MinIO and see for yourself how simple, powerful cloud-native software looks, feels and operates.