One of the more challenging aspects of Kubernetes and cloud-native development is simply deploying a cluster that your teams can start using to build apps and services. This can be time-consuming and taxing — especially to those junior developers who’ve not had much experience in the field. And once you get the cluster up and running, you then might want to have a user-friendly GUI tool to manage everything.
The complications keep piling up.
Very soon, you will find out that managing Kubernetes can be very time-consuming and complex.
But it gets worse.
What happens when you require multiple clusters for multiple teams? Are you going to use precious third-party hosting for this? Maybe a better option (at least for local dev environments) would be to host in-house. That way, you have more control, privacy, and a faster means of deploying and replicating those environments.
It shouldn’t have to be so hard, especially when you need to deploy quickly, reliably, and with a high level of repeatability.
If that sounds like your situation, it might be time for you to make use of a managed, web-based platform that can do much of the heavy lifting for your teams.
Container Management Solutions
One such platform is Portainer. This tool can easily deploy a basic Kubernetes cluster or work with a pre-existing cluster built with the likes of MicroK8s. This way, instead of having to spin up a full-blown, multi-node Kubernetes cluster, you can work with a single-node cluster to help your devs get up to speed quickly so they can spend most of their time developing specifically for your production-level clusters and less time actually building and managing the clusters themselves.
Think about it like this: You wouldn’t have your developers working directly on your production network. Instead, they typically use test networks or single-node machines to serve as their development environments. They’ll build the applications, test them, debug them, and fix them. Once they are certain the app or service is ready for full deployment, they’ll move it from the test network to production, where clients, consumers, and customers can start using the new app or service.
That’s a very traditional and widely used workflow. Given how reliable that process is, why would you want to change it for Kubernetes development? It’s proven, and as the old adage goes, if it ain’t broken … don’t fix it.
With that in mind, you can approach the Kubernetes development environment in two different ways.
MicroK8s
One popular method of deploying a Kubernetes development cluster is by using MicroK8s. This easy-to-deploy Kubernetes tool can be installed very easily (such as snap install microk8s –classic). Once it’s installed, all you have to do is enable a few services, enable the community repository, and then enable Portainer. With just a few quick commands, you’ll have a Kubernetes development environment with the added bonus of the Portainer web-based manager. With Portainer managing this Kubernetes cluster, you can work with custom templates, namespaces, Helm, applications and service deployments, Ingresses, ConfigMaps, and secrets, as well as volumes.
With such a management platform, your developers can create apps and services with easy-to-use forms and custom manifests, and they can even deploy with the help of the Helm package manager.
This deployment method works with both the community edition and the paid version of Portainer. However, if you don’t want to mess with MicroK8s, there’s even an easier method.
Because MicroK8s is so easy to install (and also allows for the simple deployment of Portainer), you can have those container development environments up and running in minutes. With such easy management, it becomes possible to create reliable, repeatable environments more quickly and easily than you can imagine.
Once again, your developers will spend exponentially more time doing what you pay them for and less time having to create their own workflows and environments. They’ll get more work done, which, in turn, helps to make your company more profitable. Who doesn’t want that?
It is, however, important to understand the role Portainer plays in this.
Portainer
Imagine, however, you didn’t have to even bother deploying MicroK8s first and, instead, could open Portainer, navigate to Environments, click Add Environment, select Create Kubernetes Cluster, and click Start Wizard.
In a matter of minutes, your developers would have access to a full Kubernetes cluster on which they can start creating apps and services that can (once they’re fully vetted and tested) eventually be migrated to your production machines. All of this is done within the Portainer GUI.
The one caveat with using this method is that all users would need to be admins to work with that platform. This shouldn’t be a problem, given it would only be used as a development environment and not for production. Even so, go into this knowing that every user on the platform would have full admin rights.
Instead of first installing MicroK8s into the mix, Portainer can be deployed with the much easier Docker, and then, using the point-and-click Portainer GUI, your team can deploy a full-blown Kubernetes development environment.
Fewer steps, less work, with all the necessary power and flexibility of container orchestration.
Few Limitations and All the Benefits
If you’ve worked with Kubernetes, even on a superficial level, you know how powerful the tool can be. At the same time, you also understand how complicated and time-consuming getting a Kubernetes environment up and running along with a GUI management platform is. And although you might have a full team of Kubernetes developers who are absolutely at home with the kubectl command, chances are pretty good you also have team members who are more comfortable with the old point-and-click of a GUI application.
Instead of taking the time to get all of your developers on the same page with Kubernetes, why not make it so every team member can develop how they want — either via the command line or a GUI? If that sounds like an environment you want to promote, don’t spend the time deploying full-blown, multi-node Kubernetes clusters from the command line, and instead take advantage of the power and ease of use offered by tools like Portainer. With such a platform, you gain all the benefits of containerization without the limitations put in place by having to use the command line interface.
If Portainer doesn’t offer what you need or if you’re considering Docker alternatives, you can always hire a third-party development team to create a web-based container management platform. Should you go that route, it would behoove your company and your development teams to request the ability to quickly deploy Kubernetes development environments so your teams can work smarter, not harder.
Should you go that route, you’ll want to make sure the team building the tool knows you want to be able to manage things like:
- Containers
- Images
- Namespaces
- Helm charts
- Volumes
- Secrets
- Environment variables
- Multiple nodes
- Scaling
- CI/CD
If a third-party development team can build a tool that includes those features (along with any company- or team-specific needs) while adhering to best practices, you can be certain the tool will make the lives of your developers and DevOps teams considerably easier.
In the end, the time you’ll save can be put to better use than spinning up multiple Kubernetes developer environments. Once you have such a platform in place, with integrated Kubernetes services, your teams will feel more at home with their products. They’ll be able to develop and deploy faster, debug apps and services with ease, and won’t have to spend an exorbitant amount of time familiarizing with the tools they need to use. After all, point-and-click is almost always more efficient than typing out complicated commands.
