Kubevious – the revolutionary Kubernetes dashboard

A standard utility for managing a Kubernetes cluster (kubectl) Is a fairly powerful tool for administration, debugging and monitoring. But if you want to get a summary of the Kubernetes cluster or work with multiple resources at the same time, it is no longer as efficient.

There are a large number of Kubernetes control panels out there today, you are probably already using one of them. For example, it can be a standard Kubernetes Dashboard or a control and monitoring panel provided by your cloud provider. All of these tools are very similar in the method of grouping information (simple hierarchy for namespaces / resources) and cannot easily be used to answer general questions about your cluster.

As an example, let’s say you have a large Kubernetes cluster and want timely answers to the following questions:

  1. Can you quickly find all the Pods that have no resource limit?

  2. Can you quickly find all the Role Bindings that are not in use?

  3. Can you quickly determine which namespace is consuming the most resources in the cluster?

  4. Can you quickly identify which images are using the latest tag?

Faced with these questions, cluster administrators have to make choices. Or waste time usingkubectlor create custom scripts or tools that explore the cluster and try to find those specific problems.

It would be nice if a graphical tool could answer these questions right away.

This missing graphical tool – Kubevious… You can see a live demo at https://demo.kubevious.io/, and look at the source code at https://github.com/kubevious/kubevious

Rethinking Kubernetes Dashboard Features

Kubevious Is a revolutionary Kubernetes control panel that is much more functional than existing counterparts. It has many interesting features, but in this article we will focus on describing a powerful rule engine that allows you to find and group Kubernetes resources to solve a given problem.

Kubevious dashboard
Kubevious dashboard

Kubevious has a hierarchical structure that will be familiar to you as it groups objects by namespace and groups them in a tree structure directly below the namespace. However, the real magic happens when you realize that Kubevious is doing additional analysis for each resource type and “tagging” it according to built-in or custom rules.

For example, without additional configuration, you will see a spy icon on objects that have access to the Kubernetes API outside of their own namespace.

Spy Objects
Spy Objects

The ability to obtain such information, especially in large clusters, is very important, as it significantly reduces the time spent on using kubectl

Kubevious also has a few other built-in markers that you might find useful. As an example, you can easily find unused RoleBindings:

Unused Cluster role bindings
Unused Cluster role bindings

You can create your own rules for other tasks.

Reasoning About Kubernetes Resources

Kubevious has its own rules engine that allows you to find Kubernetes resources with the characteristics you specify. The rule editor is also part of the GUI:

Rule editor
Rule editor

Each rule is defined in plain language Kubik which syntax resembles Javascript. For each rule, you define the body of the rule (which Kubernetes resource to look for) along with a token (what to do with the affected resource). Markers are a combination of icon, name, and color that you can use to mark affected objects.

Already exist rule librarieswhich you can reuse in your cluster. For example, you can quickly find modules without resource limits:

Pods without limits
Pods without limits
for(var container of item.config.spec.containers)
  if (!container.resources.limit)
    warning('No resource limit set');

As another example, let’s find a namespace with resources that consume more than 40% of the CPU or memory.

    .filter(({item}) => {
        const cpu = item.getProperties('cluster-consumption').cpu;
        const memory = item.getProperties('cluster-consumption').memory;
        return (unit.percentage(cpu) >= 40) ||
                          (unit.percentage(memory) >= 40);

Rules are edited with a live editor from the GUI and are instantly saved to the cluster itself. No additional tools are required to manage rules.

You can find more information on Rule Engine at official documentation

Cross-validation and resource correlations

Another impressive Kubevious feature is the correlation between different Kubernetes resources. Once you’ve created a rule that matches a certain number of resources, you don’t have to manually scroll through the viewport trying to find which ones fit.

The GUI provides you with information about which resources are affected:

Affected resources
Affected resources

When you click on any of the affected resources, the control panel will display information about that resource.

This correlation feature always works, regardless of the selection of Kubevious objects. Thus, if Kubevious can detect a connection between certain resources, you can see it in the general panel.

Shared resources
Shared resources


The rule engine is just one of the features offered by Kubevious. Kubevious has several other cool features like full-text search of all cluster resources, as well as Time Machine to detect configuration changes. If you are managing large clusters and do not want to play any more questions with kubectl, then Kubevious easy to install and control in your cluster.

Visit the site https://kubevious.io/ for more information.

Similar Posts

Leave a Reply

Your email address will not be published. Required fields are marked *