The Problem
With complex application landscapes, running Kubernetes-based workloads locally becomes infeasible. Swiftly testing applications with different Kubernetes versions can be impossible depending on organizational policies. Spinning up a Kubernetes cluster with Terraform or Cloud providers takes too long for a convenient development workflow or CI pipelines.
Getdeck is a Kubernetes-in-Kubernetes solution born from the idea to provide devs with a simple yet flexible solution to spin up a hybrid cloud development infrastructure.
We're open sourceThe Solution
With Getdeck you only need one host Kubernetes cluster that runs the operator. Getdeck creates Kubernetes clusters as deployments in a matter of seconds. The operator creates several ways to connect to that cluster and makes it simple to get started working with Kubernetes.
Fast as hell
Fresh ad-hoc Kubernetes cluster in seconds (much faster than Terraform or Cloud-providers)
Worry-free
Automatic management of clusters (via lifetime, inactivity, etc.)
Ready when you are
Shelve ("snapshot") a running cluster with state and restore them as often as needed.
Cost efficient
Run isolated workloads within Kubernetes; cheap and with the best resource utilization.
Great collaboration
Share your cluster and let your code buddy have a quick look.
Easy distribution
Automatic distribution of kubeconfig and tunnel connection to clients (using the Beiboot client package)
Usecases for ephemeral dev clusters
Exp 1: Simulate the real world
When developing an application that needs to handle high traffic and scale dynamically, utilizing cloud-based development clusters becomes crucial. By provisioning a Kubernetes cluster in the cloud, you can simulate real-world scenarios and test the application's performance under heavy loads. You can easily scale up the cluster, simulate thousands of concurrent users, and analyze how the application handles the increased traffic.
This approach allows you to fine-tune your application's scalability and optimize resource utilization before deploying it to the production environment.
Exp 2: Collaboration during development
Suppose you are working on a feature that requires collaboration with other team members, such as frontend developers, backend engineers, and database administrators. By using cloud-based development clusters, you can create a shared environment accessible to the entire team.
Each team member can work on their respective components, deploy changes to the cluster, and validate the integration of their code with the overall application. This collaborative approach fosters efficient teamwork, reduces conflicts, and streamlines the development process.
Exp 3: Only pay for active cluster usage:
When your devs use Kubernetes clusters for software development, testing, and staging environments, these clusters can consume significant resources such as CPU, memory, and storage, even when they are not actively being used. This can lead to unnecessary expenses when resources are billed based on usage. Getdeck allows developers to easily work in a dev cluster, save their development state, shut down the cluster and restore the state at a later time.
Quick Demo
This demo shows the following steps on a GKE host cluster:
- Install Beiboot
- Create a Beiboot cluster with 3 nodes and local port 8080 is forwarded to cluster port 80
- Connect to this cluster
- Disconnect and remove the Beiboot cluster
Kubernetes-in-Kubernetes
There are a couple of advantages running a logical ("virtual") Kubernetes cluster running within a physical Kubernetes cluster. The main focus of Getdeck is the on-demand creation of Kubernetes clusters for development and testing purposes.
Getdeck also has potential for other scenarios, i.g. strong workload isolation, multi-tenancy, CI, security and more. It comes with a Kubernetes operator that handles the management of ad-hoc logical clusters based on the requested parameters. This includes the Kubernetes version, the way of exposing the cluster, lifetime and so on.
A Local Kubernetes Cluster
in the Cloud
Getdeck's client does not only order a cluster based on the given parameters but also establishes a secure connection to it. It makes the requested ports (usually port 80 for http, port 443 for https) available on localhost, effectively making remote services available as they would run on the local machine. That happens entirely automatically using a secured mTLS connection. This works for any port.
Why should I develop in a cloud based cluster instead of locally?
Using instant ephemeral cloud-based development clusters instead of developing everything locally on your machine offers several advantages for developers working on applications that run on top of Kubernetes in a cloud-native environment. Here are some key benefits:
Replicating Production
Environments
Cloud-based development clusters allow you to create an environment that closely resembles your production environment, ensuring consistency and reducing potential deployment issues. It enables you to replicate the same infrastructure, networking configurations, and other dependencies, providing a more accurate development and testing experience.
Scalability and Resource
Management
Kubernetes clusters are designed to handle scalability and resource management efficiently. By utilizing cloud-based clusters, you can easily scale up or down your development environment to match the needs of your application. This flexibility enables you to test and optimize your code in a realistic environment that closely resembles the behavior of your production setup.
Isolation and Dependency
Management
Developing locally can sometimes lead to conflicts between different dependencies and versions, especially when working on multiple projects simultaneously. Cloud-based development clusters provide isolation, allowing you to manage dependencies and versions more effectively. Each project can have its dedicated cluster, eliminating potential conflicts and making it easier to manage the software stack.
Collaboration and
Teamwork
Cloud-based development clusters facilitate collaboration among team members. With shared access to the same cluster, developers can easily collaborate, share code, and troubleshoot issues together. It promotes a more cohesive and efficient teamwork environment, particularly when working on complex cloud-native applications.
Improved Development
Speed
Cloud-based clusters offer faster deployment and provisioning times compared to local development setups. They provide a streamlined workflow, allowing you to quickly spin up and tear down clusters as needed. This agility helps accelerate the development process and reduces the time required for setting up and maintaining the development environment.
Access to Cloud-Native
Services
Cloud providers offer a wide range of managed services that can be integrated with Kubernetes clusters. By utilizing cloud-based development clusters, you can easily leverage these services, such as managed databases, message queues, monitoring, and logging services. It simplifies the integration process and allows you to focus more on developing and testing your application logic.
Cost
Efficiency
With cloud-based development clusters, you only pay for the resources you need during development and testing phases. It eliminates the need for maintaining and upgrading local hardware to meet the requirements of running complex Kubernetes clusters. This cost-effective approach ensures that resources are utilized efficiently and reduces upfront infrastructure costs.
Overall, utilizing instant ephemeral cloud-based development clusters offers developers working on cloud-native applications built on top of Kubernetes several advantages, including replicating production environments, scalability, isolation, collaboration, improved development speed, access to cloud-native services, and cost efficiency. It enables developers to focus on building high-quality applications and accelerates the delivery of reliable and scalable cloud-native solutions.
Try it now