Skip to main content

Instant virtual ephemeral development and testing clusters

Star Getdeck Desktop on GithubIssues

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 source

The 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)


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.

simulate the real world

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.

collaboration with getdeck

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.

That way no costs are incurred during the times the clusters are not in use. Additionally, the virtual clusters can automatically sunset, for example on a Friday evening and easily be restored on the following Monday.

Getting started
workload locations Getdeck can work with

Quick Demo

This demo shows the following steps on a GKE host cluster:

  1. Install Beiboot
  2. Create a Beiboot cluster with 3 nodes and local port 8080 is forwarded to cluster port 80
  3. Connect to this cluster
  4. Disconnect and remove the Beiboot cluster

Beiboot demo


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.

the Getdeck Wharf logo

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.

workload locations Getdeck can work with

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

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

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

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

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

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

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.


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