Arindam Majumder

Posted on Mar 4

7 Kubernetes Tools That Will Make Your Life 10x Easier

#kubernetes #devops #webdev #programming

Working with Kubernetes and managing Kubernetes clusters can be a Nightmare(Yes, I've been there).

But with the Right tools, you can manage it effortlessly!

In this article, I will share 7 amazing Kubernetes tools that can save you time, reduce stress, and make managing your clusters feel effortless.

Let’s get started!

1. KitOps - Your AI/ML Secret Weapon

KitOps makes deployment of AI/ML models to Kubernetes very easy. If you have ever tried to move a machine learning model from your local Jupyter notebook all the way into a production Kubernetes cluster, it can be somewhat of a headache.

KitOps solves this by packaging everything-your model, code, datasets, and configs-into something called a ModelKit.

Think of a ModelKit as a container of ships for AI/ML projects. Just as containers revolutionized world trade by standardizing how goods are transported, the ModelKits standardize how we move our AI/ML projects between different environments.

Because ModelKits are built onto the OCI standards of Docker, they will integrate properly with your on-hand Kubernetes Infrastructure and Container registries.

Here is what a normal Kitfile would look like. It's just a basic YAML file which instructs KitOps about what to bundle:

manifestVersion: v1.0.0

package:
  authors:
  - Jozu
  description: Updated model to analyze flight trait and passenger satisfaction data
  license: Apache-2.0
  name: FlightSatML

code:
- description: Jupyter notebook containing Python code with training for the model
  path:./notebooks

model:
  description: Flight Satisfaction and traits analyzer using Scikit-learn
framework: Scikit-learn
license: Apache-2.0
  name: joblib Model
  path:./models/scikit_class_model_v2.joblib
  version: 1.0.0

datasets:
- description: Flight traits and traveller satisfaction training data (tabular)
  name: training data
  path:./data/train.csv
- description: validation data (tabular)
  name: validation data
  path:./data/test.csv

A Kitfile is the configuration document for a ModelKit. It's sort of like a recipe or a dockerfile for a container. It's written in YAML, hence pretty readable.

The Kitfile has been designed to be really simple, structuring your project into the following four main sections:

Project metadata: package section
Code paths: notebooks and source code
Model specifications: only one model per ModelKit
Dataset paths: supports multiple datasets

Every ModelKit is natively tamper-proof via SHA digests and versioning, so whether you are running your models on your local machine or a massive production cluster, reproducibility is guaranteed by KitOps.

Once ready to deploy on Kubernetes, KitOps takes care of all the container creation and configuration for you. Your models deploy just like any other containerized application, meaning it's easily scalable, monitorable, and manageable with your familiar Kubernetes tools. No new toolset needs to be learned, nor does an existing DevOps workflow get completely disrupted.

The best part is that because everything is packaged in a standardized way, you won't have those annoying "it works on my machine" problems when you try to switch from development to production. Your model, along with all of its dependencies and datasets, will run exactly the same way everywhere, whether that be on your local machine or in a production Kubernetes cluster.

Here's how you start working with KitOps:

Install Kit CLI from here:
Create a Kitfile manifest for your project. Add your model, datasets and code paths to the manifest, package and publish your ModelKit to container registry.
Usage in pipeline or use kit dev pull ModelKit onto local start work.

Join the KitOps Community

2. Lens - The Kubernetes IDE That Changes Everything

Lens is the most widely used Kubernetes IDE on the planet-it changed the game on how teams interact with their clusters. Imagine being able to see all changes in real-time and being able to manage your clusters efficiently. That's what Lens is all about.

The beauty in Lens is that it makes the complex simple: One local cluster or dozens of production environments, it is all a click away.

Aggregated logs and metrics, cluster management united together in one UI feels so natural, like it reads your mind even before you knew what you were looking for.

Teams using Lens say it’s like having X-ray vision for Kubernetes—cutting through the clutter of pods, nodes, and logs so they spend half the time wrestling clusters and twice the energy shipping apps that wow.

How it's different?

Real-time Debugging: You can see real-time logs, watch how the pods are talking to each other and spot if there are any problems all using just one single screen.

Productivity Boosters: It has a few keyboard shortcuts and some built-in tools that can catch errors before they become really big problems which helps you work faster and smarter.

Universal Accessibility: Lens is available on all major platforms and works the same way on all of them.

You can learn more about how to get started with using Lens here.

Checkout Lens

3. Rancher - Your Multi-Cluster Command Center

Think of it as the control room where everything is to be seen and managed, whether on your laptop or across a set of cloud providers.

Rancher adds significant value on top of Kubernetes, first by centralizing authentication and role-based access control (RBAC) for all of the clusters, giving global admins the ability to control cluster access from one location.

It then enables detailed monitoring and alerting for clusters and their resources, ships logs to external providers, and integrates directly with Helm via the Application Catalog.

If you have an external CI/CD system, you can plug it into Rancher, but if you don't, Rancher even includes Fleet to help you automatically deploy and upgrade workloads.

Quick Setup on AWS

First, you'll need:
- An AWS account
- AWS Access Key and Secret Key
- Terraform installed on your computer
Create a basic AWS policy for permissions:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "ec2:*",
            "Resource": "*"
        }
    ]
}

Get the code and set it up:

# Get the quickstart code
git clone https://github.com/rancher/quickstart
cd quickstart/rancher/aws

# Set up your configcp terraform.tfvars.example terraform.tfvars

Edit terraform.tfvars with your details:

aws_access_key = "your-access-key"
aws_secret_key = "your-secret-key"
rancher_server_admin_password = "your-secure-password"

# Optional: Change these if needed
aws_region = "us-east-1"    # Pick your closest region
instance_type = "t3a.large" # Bigger if you need more power

Run it:

terraform init
terraform apply --auto-approve

After a few minutes, you'll get a URL like https://rancher.xx.xx.xx.xx.sslip.io. Open it in your browser, and log in with:

Username: admin
Password: (the one you set in terraform.tfvars)

What You Get

A Rancher server running on its own Kubernetes cluster
A separate Kubernetes cluster for your work
SSH keys in the quickstart/rancher/aws folder to access your machines

The real beauty of Rancher is when things start to get busy: you're running dozens of clusters across different teams and environments, and instead of jumping between different tools and dashboards, it's all there right in front of you. Update a cluster? Click. Who changed something last week? Click. That's how it is that straightforward.

What really sets Rancher apart, though, is the way that it automates the mundane for you. Updates that took hours can now happen in the background. Security checks happen automatically. And if things do go wrong, you'll know just where to look.

You can read more about how to get started using Rancher here.

Join the Rancher Community

4. Argo CD - GitOps Made Simple

Argo CD is a tool that continuously monitors your Git repositories and keeps your Kubernetes clusters in sync with what's in your code. You don't have to manually check and worry about what's on github and what's being deployed. Argo CD does it for you.

How this works is that when you make changes to your files in Git, Argo CD notices these changes automatically. Then it will show you what exactly it is going to change in your cluster before it does anything. And if something goes wrong, it can roll back to the last working version.

Key Features:

Continuous Sync: Argo CD constantly checks your Git repository and makes sure your cluster matches what's in your code - if something's different, it fixes it automatically.

Easy Rollbacks: If a deployment breaks something, you can quickly go back to the previous working version easily.

Simple Integration: It works with tools like Helm and Kustomize, and you can see exactly what changed between versions.

Here's how to start working with Argo CD:

Install Argo CD in your cluster:

kubectl create namespace argocd
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml

Access the Argo CD API Server (using port forwarding):

kubectl port-forward svc/argocd-server -n argocd 8080:443

Get your initial admin password:

kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d

You can learn more about setting up and using Argo CD by following the official getting started guide.

Join the ArgoCD Community

5. K9s - Terminal Lovers' Dream

If you are like me and don't like typing endless kubectl commands, K9s is something you should check out. It's a terminal-based UI that makes managing Kubernetes clusters feel like operating a modern application, yet with all the speed of command-line tools.

It's like a control center for your clusters directly in the terminal. It will watch the changes in real-time and show you just what you need to know at any point in time.

But most importantly, almost everything you do with kubectl, you can do with this, only a lot quicker. Want to see some logs? Press a key. Want to know what is taking up all your resources? It's right there. It feels very natural.

Installation Guide

K9s is available for all major platforms. Here's how to install it:

For MacOS users:

# Using Homebrew (recommended)
brew install derailed/k9s/k9s

# Or using MacPorts
sudo port install k9s

For Linux users:

# Using LinuxBrew
brew install derailed/k9s/k9s

# Using PacMan (Arch Linux)
pacman -S k9s

For Windows users:

# Using Scoop
scoop install k9s

# Using Chocolatey
choco install k9s

Important Setup Notes:

K9s requires a 256-color terminal. On Unix-based systems, set your TERM environment:
```
export TERM=xterm-256color
```

For editing resources, set your preferred editor:

export KUBE_EDITOR=vim# or your preferred editor

Once installed, simply type k9s in your terminal to launch the interface.

Read more about how to get started with K9s here.

Join the K9s Community

6. Octant - A Developer-Centric Kubernetes Interface

Octant is a tool made to enhance developer experience on Kubernetes and allow a new approach for understanding complex, distributed systems. Octant provides a clear view into the state of your Kubernetes clusters through an intuitive web interface.

It comes in very handy when understanding complex relationships between resources and when troubleshooting application deployments.

Core Capabilities:

Resource Views: Octant shows you exactly how your resources are connected and what's happening inside your cluster, making it easy to spot issues and understand relationships.
Plugin Support: You can add your own custom views and tools through plugins, which is helpful when you need to see specific information about your applications.
Developer Tools: It comes with practical features like log viewing, config editing, and basic metrics, so you can handle most daily tasks without switching between different tools.

Probably the most characteristic feature of Octant is a resource viewer which displays the hierarchical relations between the Kubernetes objects.

When opening any Pod, associated ConfigMaps, Secrets or Services will show up in UI as indented child of the relations:.

This tool is very helpful, when it comes to understanding the state of your applications in the cluster. It is pluggable, so teams can add their own visualizations and functionality specific to their needs, whether that be showing metrics from monitoring systems, or custom resource states.

To get started with Octant, simply:

Download the latest release from the official repository
Fire up Octant and point it to your kubeconfig
Open localhost:7777 in your web browser

Join the Octant Community

7. Kubevious - Catch Problems Before They Blow Up

Kubevious is a specialized Kubernetes dashboard for configuration analysis and validation. It helps groups identify potential problems in cluster configuration before actual issues show up at the production level.

But what really makes Kubevious shine is the relationship analysis it does of resources and its auto-detection of configuration issues.

For example, when you're on a Pod view, you will be able to visualize ConfigMaps and Secrets and network policies that relate to this pod in a nice, hierarchical layout, showing you what depends on what.

Kubevious UI is highly graphical. Kubevous renders Kubernetes objects in a tree structure. Each node comes with a unique set of properties.

As another example, a Namespace node shows apps that consume most resources, but ServiceAccount node - a matrix of RBAC rules. Error and warning alerts are visible at each tree node level for the entire subtree.

How it's different?

Visual Relationships: Kubevious shows how your Kubernetes objects are connected to each other in a simple tree view, making it easy to understand how everything fits together.
Configuration Checks: It automatically scans your setup for common mistakes and security issues, then tells you about problems before they cause actual failures.
Resource Analysis: You can see exactly how much CPU and memory your applications are using, and quickly spot if any part of your system is using more resources than it should.

To get started with Kubevious, visit the link here.

Join the Kubevious Community

Wrapping Up

Look, managing Kubernetes isn't easy-we've all been there, staring at a terminal, trying to figure out why our pods just won't start. These tools will make your life less hard if you use them correctly.

Each of these tools takes some time to get used to, and with time you will be more comfortable with each of them. But these tools will definitely make your journey with Kubernetes much easier.

Quick Reference Table:

Tool	Primary Use Case	Common Scenarios
KitOps	AI/ML deployments	Managing ML models and dependencies
Lens	Cluster visualization	Day-to-day cluster operations and monitoring
Rancher	Multi-cluster management	Managing multiple clusters across different environments
Argo CD	GitOps deployments	Automated deployment from Git repositories
K9s	Terminal-based management	Quick cluster operations via command line
Octant	Resource relationships	Understanding dependencies between resources
Kubevious	Configuration analysis	Validating and troubleshooting configurations