Why Design Patterns Matter for Scaling Kubernetes Apps

Get your facts straight

It’s now common knowledge that human beings have tremendous untapped potential and use only about 10% of their brain capacity. And it’s well-established that stretching before exercise is an excellent way to prevent injury. And of course those of us with facial hair know that you always get a closer, more comfortable shave by using warm water instead of cold water.  

I think most of us “learned” the above “facts” from reputable sources or from what we believe to be our own verifiable experience. But none of the above statements is actually true. Scientists have proven that all parts of the brain are highly specialized and there’s no evidence of unused areas that can suddenly be harnessed. And though a gentle aerobic warm-up can prepare muscles for a workout, studies show that stretching before exercise has no effect on injury rates. And yes, while warm or hot water can feel good and soften your facial hair, it’s cold water that causes hair to stand up, making it easier to cut and doing more to prevent irritation and razor burn than warm water.

It takes a while to unravel and discredit erroneous ideas and concepts that seem logical or at least reasonable, especially once they develop critical mass and momentum – which can occur overnight in our digitally connected world. Think about how many people believe it’s perfectly safe to eat food that fell on the floor as long as you pick it up within 5 seconds – another falsehood, given that bacteria can attach to food immediately upon hitting the floor.

So what does any of this have to do with design patterns and scaling Kubernetes apps? Let’s find out. 

Design patterns and antipatterns

There are solutions in both our day-to-day and professional lives that are based on well-tested and verifiable methodologies. They have usually been developed over time by experienced practitioners and are consistently followed by them. You can think of these successful solution approaches as design patterns. On the other hand, there are many ideas and practices that sound good, are widely used, and yield beneficial results initially – and there may even be plausible reasons that explain why outcomes are initially positive. But these methodologies have shortcomings that ultimately lead to suboptimal, counterproductive or even disastrous results. You can think of these as design antipatterns.  

Design patterns have been an essential part of the software development process for nearly three decades, but they are frequently used across the broad spectrum of engineering disciplines to address specific requirements or challenges. And given how challenging and complex it is to manage and scale Kubernetes workloads and applications, it behooves us to research and follow design patterns that can yield the results we desire and save us a lot of headaches in the medium-to-long run.   

Patterns and technology for K8s scaling

StormForge is successfully enabling its customers to run their Kubernetes applications at scale to meet dynamic business needs. This success can be attributed to innovative technology as well as the recommended use of established design patterns that address inherent resource contention in multi-tenant environments and also address the need for scaling across multiple dimensions; e.g., scaling application pods both vertically and horizontally, scaling the underlying cluster, and knowing when to perform each of these tasks. A couple of design patterns are of particular importance: Predictable Demands and Elastic Scaling 

• The Predictable Demands pattern establishes application resource requirements and dependencies at runtime. Kubernetes can then efficiently schedule pods across all nodes and ensure that each app gets its required resources. 
• Understanding Predictable Demands is the starting point for scaling our applications. The Elastic Scaling pattern is what ensures that all of our apps across the cluster can accommodate fluctuating demand by automatically adding or removing optimized pods and cluster resources. It’s a big picture approach that encompasses not just pod and cluster scaling but also application tuning. 
• In addition to design patterns, the “special sauce” that StormForge brings to the table is our patent-pending ML technology, which trains our learning models. This ML-based approach deepens our understanding of application behavior and their predictable demands, and provides recommendations around elastic scaling for maximum efficiency and uptime.  

Antipatterns to avoid

Another key to success when scaling Kubernetes apps is avoiding the temptation to spin our wheels on ineffective antipatterns. It can be really tempting to skip some of the hard work that the design patterns require – but this is a shortsighted path that leads to classic antipattern pitfalls, which cost time, money and opportunities. Such antipatterns include relying on solution methodologies that address only the simplest elements or “lowest hanging fruit” among our challenges. And as with our well-established myths discussed above, we also need to resist the urge to follow antipatterns that emphasize “folklore” tips that may not apply to our applications. Finally we need to avoid shortcut-driven antipatterns that focus on only parts of our complex Kubernetes cluster without considering the whole picture.