I’m just going to put it out there: low-code application platforms are sweet. The way they apply automation to speed up application coding, one of the most time-consuming phases of the software development lifecycle, is super cool. And there is plenty of evidence that enterprises from all over the world are taking advantage of this speed to innovate, grow, and increase competitiveness.
The best low-code platforms create enterprise-grade web and mobile applications that run on traditional trusted technology stacks. In the leading low-code platforms, fast development in a visual modeling IDE is followed by the click of a button, which starts the automation that writes the code, builds the application, and deploys it all across a full DevOps lifecycle to production.
What is created is a robust, secure, and scalable enterprise application that runs on traditional middleware. And, this is important. Why? Because things are changing in the infrastructure world, and deploying applications to traditional middleware means that low-code teams will be able to take advantage of these advances.
Take containers, for example. These are new lightweight entities that encapsulate software to make it portable, scalable, and manageable. Let’s go back in time and take a look at how containers came about.
We Can Hardly Contain Ourselves: A Brief History of Containers
Way back in the day, software used to run on physical computers called “servers.” Your dad might remember those. Application software actually ran “on top of” an intermediary layer that translated software commands to CPU instructions. This intermediary layer was the “operating system.” Organizations often purchased an entire server to run one piece of application software, which resulted in a fair amount of wasted computing horsepower in the server.
So, a company called VMware devised a way to create multiple “virtual machines” (VMs) that could coexist in a single server. In each of these VMs was a full copy of an operating system and the application software to run. VMs, therefore, increased density and made better use of physical computing resources. However, since each of these VMs contained a full copy of an operating system, overhead is still present. So, we needed a way to drive even more efficiency.
Different attempts to divide resources efficiently were made in various operating system platforms. Solaris Zones and IBM mainframe LPARs were two early approaches to solving this efficiency problem. But, it wasn’t until a community of open-source smarties working on the Linux operating system took on this challenge that serious progress was made.
Since Linux provided low-level controls of the application, system processes, and memory (Cgroups, Namespaces, SELinux, etc.), it became possible (with some tinkering) to create a “container” around a single application and its libraries, thereby segregating it from all the other applications running on the operating system. The benefits of this setup include:
- High efficiency with increased application density in a single operating system
- Security for the applications running in the container
- Portability with the ease of moving the container to another machine or operating system
Containers, Meet Microservices
Things get interesting when you pair containers with one of the hottest trends in application software architecture: microservices. Microservices break an application up into a bunch of individual functions running as software services that speak to each other over prescribed application programming interfaces (APIs).
Moving to a distributed microservices architecture has its own set of benefits:
- Flexibility (fast change): Individual services can be updated and redeployed without impacting the entire application.
- Elasticity: Stateless services can be scaled horizontally as needed.
- Resilience: Small services can be restarted quickly in a fail-fast application design.
A single application then can be made up of tens, hundreds, or thousands of microservices.
Containers enable the encapsulation and deployment of microservices in new “cloud-native” application architectures. Containers provide the security, portability, and isolation for these individual services.
Piloting Container Ships: Kubernetes and More
With thousands of containers running microservices for many different applications, things can get out of hand quickly. Well, that’s where container management platforms such as Kubernetes come into play. Kubernetes, an open-source project that originally came from “The Borg,” which is the software that Google runs internally for all of their operations, is the leading container management platform.
Cloud-native application architectures that use containers and systems like Kubernetes are enabling organizations to focus on accelerating innovation and delivering value to the business on a massive scale.
Containers and Low-code: A Matchmaker’s Dream
So, wait. Low-code helps drive business innovation, growth, and competitiveness? And containers help accelerate innovation and business value? What if we got those two together? This is a great idea. And, it’s exactly what you can do when you have a low-code platform that deploys to traditional application middleware stacks because these stacks run perfectly in these new containers. So, develop in low-code; deploy to containers. And, we all live happily ever after.