Cloud Native Journey Part 2: Technical Adventure
Tags: kubernetes, vcluster, devspace, loft
Published: 2022-06-16 18:47:13

By Tyler Charbonneau

*This is part two of our multi-article series exploring cloud-native technologies. For the introduction and to learn more about essential goals and expectations that impact the setup process, check out [part 1 here](https://loft.sh/blog/cloud-native-journey-part-1-defining-goals-and-responsibilities/).*

Most organizations these days are looking for cloud-native systems that are feature-rich, reliable, and accessible from anywhere.

As explained in the previous article in this series, it’s important that cloud computing include sound planning, design, and deployment of remote services following [these integral principles](https://docs.microsoft.com/en-us/dotnet/architecture/cloud-native/definition): 

* application scalability
* loose coupling of systems and services
* transparency and observability
* smaller codebases and features *instead* of monolithic ones
* reliance on containers, service meshes, APIs, microservices, and stable infrastructure

The technical adventure of cloud-native deployment may seem daunting. There are numerous ways to successfully implement a cloud-native setup. In this guide, you’ll learn the technical ins and outs of establishing your cloud-native infrastructure by exploring the options of multi-cloud versus single-cloud cluster tenancy.

## Exploring Technical Implementation

Cloud-native transitions require plenty of expertise to complete, though the process has become increasingly approachable with the rise of SaaS and PaaS. However, acquainting yourself with some technical basics is immensely helpful. The cloud’s benefits stem from [common elements](https://docs.microsoft.com/en-us/dotnet/architecture/cloud-native/definition) integral to cloud-native infrastructures:

* **microservices**—bundles of loosely-coupled APIs and features
* **containers**—virtual packages of mission-critical application code, software, and dependencies
* **modern design**—modular, scalable, and nimble infrastructures that streamline deployment
* **backing services**—vital supporting services like databases, caches, and more that are exposed to help ecosystems run smoothly
* **automation**—efficient processes that run automatically in response to events or passage of time to facilitate management without excessive human intervention

Since these elements support a cloud-native deployment and the applications it contains, they are imperative for most organizations regardless of size. 

Microservices have especially exploded in popularity. A year and a half ago, the API platform company Kong found in a survey that [84 percent of organizations](https://newrelic.com/blog/best-practices/rethink-your-microservices-monitoring-strategy) have adopted a microservices approach and that companies run 184 microservices on average. That’s an impressive number, and this complexity requires a system that can handle such dynamic demands, as a traditional system wouldn’t have the flexibility to do so.

Cloud-native systems are therefore **distributed**, which means they are spread across virtual machines and containers. These components are vital to maintaining near-flawless uptime for all applications that each leverages its own share of computing and memory resources. Kubernetes has arisen to facilitate this resource management with its topology.

## Introducing Cluster Models

These days, Kubernetes is the go-to solution for managing containerized environments. While Kubernetes has multiple building blocks per the containerized computing model, arguably, the most critical component is the **cluster**.

In cloud computing, these clusters contain multiple nodes, which are either virtual or physical machines, that run simultaneous workloads. Applications generate these workloads in response to user activity.

There are also many more [integral components](https://kubernetes.io/docs/concepts/overview/components/) in the Kubernetes cluster, including the following (simplified) components:

* the control plane
* nodes
* pods
* containers
* container runtimes
* schedulers, API servers, the kubelet, and any supporting components like DNS

The cluster contains everything needed to run applications effectively around the clock. The cloud-native nature of cluster components allows rapid, horizontal scaling according to user activity. Additionally, clusters [ensure high availability, high performance, and load balancing](https://www.capitalone.com/tech/cloud/what-is-a-cluster/) to prevent your systems from becoming overburdened. Understanding the basics is important to getting a better grip on your own cloud-native deployment.

Clusters are integral to cloud-native setups since these virtualized resources are so easy to scale—without needing to add your own physical infrastructure. On-demand provisioning is possible, as is simultaneously deploying machines across numerous geographical locations. . 

Organizations can strategically choose to run larger clusters called multitenant clusters or to maintain collections of smaller clusters called single-tenant clusters. These smaller clusters are more specialized. Which approach is superior?

### Multi-tenant Clusters

Cluster multi-tenancy describes a setup where multiple teams share one cluster or where a team shares multiple clusters. These clusters are larger overall by default since they must house every component and dependency integral to every application hosted in them.

Like a public cloud, shared clusters support diverse workloads. They also host development and production deployments alike. Different internal departments can leverage these shared clusters. How your organization defines a tenant will affect how each coexists with others in the cluster.

Shared clusters rely on varying degrees of isolation to protect data and prevent multi-workload interference. The container model provides some latitude here. For example, administrators can opt for zero isolation. While it is easier to manage, the lack of control might be problematic for some organizations. 

Conversely, Kubernetes namespaces help provide isolation within Kubernetes—effectively acting like folders and providing better intra-cluster organization. Opting for some isolation also offers better security. However, it’s impossible to achieve complete isolation with multi-tenancy due to its nature.

So why might you opt for shared clusters? For one, managing a smaller group of clusters, which includes updating, provisioning, backups, and restoration, is easier than managing numerous clusters. It’s also easier to map out your infrastructure at a higher level with fewer pieces. Finally, less complexity also means less overhead.

If you’re looking to define shared cluster access for your teams, Loft helps you [easily configure access](https://loft.sh/docs/getting-started/cluster-access#operation/readVirtualclusterLoftShV1NamespacedHelmRelease) based on your needs. Generally, closely delegating residency and access in shared clusters helps better manage them at scale. 

Unfortunately, multi-tenancy does limit the granularity and control you have over your Kubernetes system. By bundling more workloads together, cluster failures can negatively impact a greater number of application workloads—and therefore end users. Availability can suffer as a result.

### Single-Tenant Clusters

The alternative to multi-tenant clusters is single tenancy. Compared to multi-tenancy, single tenancy assigns one internal team, application, or department to a given cluster. Organizations must therefore maintain a larger number of clusters overall with this model. These deployments are inherently more isolated because they give each entity its own space in which to operate. 

On the communication side, NetworkPolicy defines flows of information across the cluster. For updates and pod creation, PodSecurityPolicy gives you configuration options. However, note that Kubernetes’s core components like the kubelet, API server, kube-proxy, and others will remain shared.

Services under single tenancy tend to be more available since distributing workloads are less susceptible to impacts from critical failures. Therefore, single tenancy is better for the end user and simplifies the remediation process.

The reserved clusters of a single-tenancy model aren’t perfect. After all, it can be more expensive to operate more clusters. Despite this, most companies are opting for single tenancy because of the benefits mentioned above and the added flexibility.

## Conclusion

On the journey to cloud-native deployment, understanding the technical approaches you can take is paramount. How you deploy your clusters will have a major impact on application performance. Your strategy will also influence the topography of your cloud-native infrastructure. Before deployment, ample assessment of goals, expertise, and technical requirements is important.

*Photo by [Nitish Meena](https://unsplash.com/@nitishm?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) on [Unsplash](https://unsplash.com/?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText)*