Managing applications on Kubernetes can be challenging, especially since Kubernetes works in a distributed manner and there are countless resources for managing, This becomes even more aggravating as companies begin to scale their Kubernetes Clusters. Helm, the Kubernetes package manager simplifies application management by offering a structured way to define, install, and manage Kubernetes applications. It packages all the different components of the application such as Persistent Volumes, Deployments, ConfigMaps, and secrets into a single template which can be modified as required. This template is known as a Helm chart, making deploying applications to the Cluster easier. It has become a pillar for streamlining application deployment and lifecycle management.
Helm's usefulness lies in its ability to standardize and automate Kubernetes deployments. By abstracting Kubernetes manifests Helm allows developers and Ops teams to focus on deploying consistent and repeatable configurations across different environments. This accelerates workflows, reduces configuration errors, and makes managing applications across environments more efficient. However, as adoption scales, so do the challenges of managing Helm applications.
Helm alone doesn’t address every operational requirement and introduces a few challenges. After deploying a chart, operators need to properly manage the chart versions. It is also difficult to relate which resources are deployed by the Helm charts and managing configuration drifts. These gaps become apparent in multi-team setups or environments requiring enhanced governance, monitoring, and troubleshooting capabilities.
Some tools are designed to manage Helm applications on Kubernetes and serve as a layer of abstraction. These tools are built upon the core functionality of Helm and enhance the Developer Experience. They often provide intuitive graphical interfaces, enabling users to easily visualize the state of deployed applications, track version history, and manage configurations without relying solely on the command line. Advanced capabilities, such as role-based access control (RBAC), auditing, and team collaboration features, make these platforms particularly valuable in multi-team environments.
This blog will explore two such tools for managing Helm applications and Kubernetes clusters. Devtron and KubeApps. We will be looking at how these tools help with managing the Kubernetes cluster and the Helm application deployment and lifecycle and comparing the two.
What is KubeApps
KubeApps is an open-source tool that provides a simple, user-friendly interface for discovering, deploying, and managing Helm charts on your Kubernetes clusters. It offers a graphical interface for deploying Helm charts and managing their lifecycle. With KubeApps, users can access multiple Helm repositories, manage application configurations, and view the status of deployments across Kubernetes clusters.
Installing KubeApps is straightforward and typically involves deploying it as a Helm chart within a Kubernetes cluster. Once deployed, the KubeApps dashboard can be accessed through a web interface, providing instant visibility and control over Kubernetes applications.
To learn more about KubeApps, please check out their GitHub repository.
What is Devtron
Devtron is an open-source Kubernetes dashboard that is designed to give the user comprehensive visibility into their cluster, while also reducing context switching and managing Helm applications that are deployed in the Kubernetes cluster. Devtron can connect to multiple different Kubernetes clusters and enable you to observe and manage the clusters with ease. To use Devtron, you will have to install it on your target Kubernetes cluster.
Devtron lets you use public helm charts for integrating tools from the Cloud Native ecosystem such as Nginx or Prometheus, or you can package your custom application, and upload it to a chart repository. Then you can deploy the chart on Devtron and manage your application workload. Devtron has a couple of robust features for managing applications and gaining comprehensive visibility into Kubernetes resources which will be discussed below.
To read more about Devtron, please refer to their documentation and the GitHub repository.
Helm Chart Management
Helm is Kubernetes' package manager, simplifying the deployment and management of applications. It uses charts, which bundle all the resources like Deployments, Services, and ConfigMaps required for an application. With Helm, you can deploy an entire application stack with a single command, manage updates, and roll back easily if something goes wrong. It streamlines operations by consolidating multiple YAML manifests into one manageable package.
Helm is essential in Kubernetes as it saves time, reduces errors, and promotes consistency across environments. It supports version control, dependency management, and configuration overrides, making it perfect for teams working across development, staging, and production.
KubeApps
On first accessing the KubeApps dashboard, you will be able to see all the Helm charts that have been deployed to the target Kubernetes cluster. You can see the Helm installation status for the particular charts and you can also filter out the deployed charts according to the cluster and namespace.
KubeApps provides an entire Catalog where you can see Helm charts from different repositories. By default, you can only see the charts created by bitnami. However, KubeApps lets you add custom chart repositories. After adding the Custom Repository, you will be able to view the chart in the catalog. The charts in the catalog can be filtered based on Chart Name, Category, its package repository, and package type.
When adding custom charts to the Repository, KubeApps provides a lot of flexibility with how you can add custom Charts. It allows you to chart in various packaging formats such as base Helm Charts, and Helm Charts via FluxCD and Carvel packages. You can also add Charts from private chart repositories by defining the correct chart endpoint with the appropriate authentication method. You can also configure KubeApps to sync with the chart repository at certain intervals of time.
When trying to deploy any chart from the Catalog, KubeApp provides several options that streamline the deployment process. On the chart’s home page, it provides the entire chart Readme file which you can refer to for configuring the chart. It also provides a visual editor which lets you configure the chart using the GUI, instead of writing a YAML file. The YAML editor of KubeApps has a Diff view, which shows the differences between different chart versions. If you are deploying the chart for the very first time, it shows the differences between the default chart and the changes that you have made.
[Fig.4] KubeApps Chart Visual Editor
Once the chart has been deployed, KubeApps shows some useful information about the deployed chart and allows certain actions as well. For instance, it shows the number of pods that are a part of the Helm deployment and shows if the deployed application is ready or not. It shows the number of pods that are running, along with it URL for any services such as LoadBalancer, and any application secrets that might be required for accessing the application. You also get to see the installation notes. However, it is important to note that these notes are not editable. KubeApps will also give insights into the deployments, services, and other resources that have been deployed by the Chart. You can also see the live Manfiest file and see its configurations. You can also perform certain actions within the chart such as upgrading the chart version, rolling back to a previous version, or deleting the Helm application entirely.
[Fig.5] KubeApps Chart Deployment
Devtron
Devtron’s Kubernetes Dashboard helps manage Kubernetes applications with its dedicated Helm Apps management dashboard. In this dashboard, Devtron lists all Helm applications deployed across multiple Kubernetes clusters providing a 360-degree view of all applications. You can also filter applications of choice using multiple filters such as Projects, Clusters, and Namespace. By providing a Helm dashboard similar to the Kubernetes dashboard of Devtron, you can now manage all your Helm applications in a single pane of glass. Having a single and intuitive application management dashboard helps you to easily navigate through multiple applications that are spread across multiple Kubernetes clusters without any context switching and tedious processes.
The Helm App dashboard of Devtron allows you to create and deploy new applications to target the Kubernetes cluster and environment. By navigating to the top right corner at Create > From Chart Store you are redirected to the Chart Store entity of Devtron. The Chart Store contains multiple Helm charts readily available for deployment. You can configure your own Helm registry to deploy custom applications too.
Devtron’s Helm dashboard comes with some advanced capabilities like troubleshooting the application, managing the configurations, and handling the configuration drifts. Some more features that devtron provides are resource grouping at the application level, real-time health status, and Deployment History.
In case you need to visualize the logs of specific pods and perform some troubleshooting. Devtron provides you the capability to visualize the real-time logs on the same Helm dashboard. Some more additional features that the Helm dashboard provides to you are Manifest (view and edit live manifest), and Events.
For troubleshooting errors of applications, with the Helm dashboard of Devtron, you can launch a dedicated Terminal for a specific pod and fire up some commands for troubleshooting. You can use some advanced capabilities of Devtron’s Helm dashboard for troubleshooting like Launch Ephemeral Containers.
To trace the changes in applications and their configurations at scale the audit log is something that can help. The Helm dashboard of Devtron provides you with a complete audit log of each deployment of applications along with their configurations. The Deployment History of Helm dashboard provides an audit log of deployments with day-date-time for deployment, an artifact that has been deployed, values.yaml, and the Helm-generated manifest. If your new deployments does not meet the expected outcome you can perform one-click rollbacks with this Helm dashboard.
Before executing the newer version deployment of your Helm application, you may want to check the previous configurations. The Helm dashboard of Devtron allows you to compare configurations of previous deployments with the newer ones.
For optimizing the cost of infrastructure you may sometimes need to scale down some workloads of applications. With Devtron the workloads can be scaled down with a single click.
Additionally, Devtron lets you view the applications that are deployed via ArgoCD as well as FluxCD in the Kubernetes clusters. If a FluxCD application is deploying a Helm chart, you can view and manage the application as well.
Multi-Cluster Management
A multi-cluster setup is crucial for scalability, fault tolerance, and compliance in Kubernetes environments. Distributing workloads across multiple clusters helps ensure high availability and localize deployments closer to users for reduced latency. It also provides a safeguard against cluster-level failures, preventing a single point of failure. Additionally, organizations often use multi-cluster setups to separate environments such as production, staging, or development clusters.
Managing multiple Kubernetes clusters introduces challenges like maintaining consistent configurations, securing communication between clusters, and gaining unified visibility across them. Tools and strategies for multi-cluster management are essential to streamline operations, prevent configuration drift, and efficiently orchestrate deployments at scale. These solutions empower teams to leverage the full potential of Kubernetes without being overwhelmed by operational complexity.
KubeApps
KubeApps provides support to deploy applications across multiple Kubernetes clusters. However, you cannot add the cluster directly from the KubeApps dashboard. Instead, you need to pass in the cluster endpoints and CA tokens within the values.yaml file while installing KubeApps. For an existing KubeApps installation, you can use the helm upgrade command to add additional clusters. The below custom values.yaml file is used for adding more clusters to your KubeApps installation.
clusters:
- name: cluster-1
apiServiceURL: https://DNS_OF_FIRST_WORKLOAD_CLUSTER_API_SERVER:6443
certificateAuthorityData: CA_DATA_FOR_FIRST_WORKLOAD_CLUSTER_API_SERVER
- name: cluster-2
apiServiceURL: https://DNS_OF_SECOND_WORKLOAD_CLUSTER_API_SERVER:6443
certificateAuthorityData: CA_DATA_FOR_SECOND_WORKLOAD_CLUSTER_API_SERVEROnce the cluster is successfully connected, you can view and deploy the Helm applications to the different connected clusters.
Devtron
Devtron supports adding multiple Kubernetes clusters, to which you can deploy various Helm charts to. Adding the cluster is as easy as passing in the cluster’s kubeconfig file, or manually fetching the Cluster URL and bearer token.
Once the cluster is deployed, you can simply select the correct environment to deploy the application to and click on Deploy. The Helm chart will be deployed to the particular Kubernetes cluster. Devtron also lets you visualize the Helm charts deployed across various clusters in a single unified dashboard. You can also apply filters for the different clusters or namespaces.
User Security & Team Collaboration
Security in a Kubernetes dashboard is critical because it often serves as a centralized interface for managing clusters, workloads, and sensitive configurations. Without robust security, such dashboards become potential entry points for unauthorized access, leading to data breaches or accidental misconfigurations that can disrupt operations.
Role-Based Access Control (RBAC) plays a pivotal role in securing Kubernetes dashboards and fostering safe team collaboration. By defining roles with specific permissions, RBAC ensures that users can only access and modify resources relevant to their responsibilities. For instance, a developer might be allowed to view logs and deploy applications but not alter cluster-wide configurations. This segregation of duties minimizes the risk of human error, protects critical resources, and allows teams to work concurrently without stepping on each other’s toes. RBAC not only enhances security but also enables efficient collaboration by providing tailored access to the right people.
KubeApps
By default, KubeApps does not provide any authentication mechanism. It relies on the authentication and authorization mechanisms that are built into Kubernetes itself.
Every request to KubeApps relies on a trusted Kubernetes API token, ensuring that interactions with the Kubernetes API server are tied directly to the user’s permissions. This mechanism guarantees that users can only view and manage applications they’re authorized to access such as those within a specific namespace. If a user attempts to access a restricted resource, Kubeapps responds with a clear error message outlining the required roles, providing transparency while maintaining strict access control.
KubeApps supports two main types of authentication mechanisms
- OpenID Connect
- Service Account
To facilitate team collaboration within KubeApps, you would be required to manually configure the Kubernetes role and rolebinding for each user. Similar to the multi-cluster setup, the OIDC configuration has to be set within the values.yaml file itself.
Devtron
Devtron has a dedicated tab under Global Configurations for Authorization where you can manage access to your Kubernetes infrastructure. You can Add Users by navigating to the User Permission tab of Devtron, where you will be able to configure a robust Resource Base Access Control (RBAC) for each user. For each new user, you can configure access down to the smallest unit of your Kubernetes cluster through an intuitive user interface.
Devtron provides you support for defining Permissions Groups to which you can attach some specific permissions and the same permissions will be applied to users added to the group. For example, for every new joiner in the team, you can give view access to some application that you want them to see and these permission groups can be directly assigned whenever you add a new user.
For the ease of accessing your Kubernetes infrastructure and to eliminate the headache of maintaining separate credentials for accessing Devtron’s dashboard, Devtron has support for Single Sign-On(SSO). Where you get seven SSO options to choose one whichever suits you and your teams.
Cluster Visibility & Management
Proper visibility into Kubernetes workloads is essential for maintaining application health, diagnosing issues, and optimizing resource usage. Kubernetes orchestrates various components, such as pods, deployments, and custom resources, which can interact in complex ways. Without clear visibility, teams may struggle to understand how workloads are performing, why failures occur, or how changes affect the cluster. This can lead to prolonged downtime, inefficient resource allocation, and reduced confidence in deployments.
Visibility tools provide insights into real-time resource utilization, pod health, and the status of custom resources, enabling teams to troubleshoot issues quickly and make informed decisions. For example, identifying a pod stuck in a "CrashLoopBackOff" state or pinpointing misconfigured CRDs becomes much easier with dashboards or CLI tools that surface these details. By ensuring visibility, organizations can improve reliability, streamline operations, and maintain smoother development-to-production workflows.
KubeApps
KubeApps shows you all the resources that are deployed in the cluster via the Helm charts. However, for any resources that are not deployed via a Helm chart, KubeApps will not provide any insights into those resources. To view those resources, you will need to switch to the terminal and use kubectl to view the resources and get insights into them.
Devtron
Devtron provides full visibility into the cluster through its Resource Browser. As the name suggests, it shows you a complete list of the resources within the cluster. As you can see in the below image, the resource browser has listed all the clusters connected to Devtron along with useful information such as CONNECTION STATUS, NODES, NODES ERRORS, K8S VERSION, CPU CAPACITY, and MEMORY CAPACITY of each Kubernetes cluster.
*Within the enterprise version of Devtron, you can also visualize all the different clusters that are connected to the cluster.
When navigating to each cluster you get an Overview of the selected Kubernetes cluster. You can visualize information about the utilization and availability of assigned resources, the owner of the cluster, and a Readme file where we can describe the cluster. The Readme attached to the Kubernetes cluster can help teams collaborate and understand the purpose and configuration of our cluster.
* The enterprise version of Devtron comes with additional features such as a catalog framework which lets you create a custom catalog that contains information about the cluster such as Cluster owners, backup strategies, etc. There is also an integration with silver-surfer which helps during Kubernetes cluster upgrades by showing the APIs with breaking changes.
At the Node level of the Kubernetes cluster, Devtron’s Resource Browser allows executing essential operations like visualizing and editing live YAML manifest, viewing the Node Conditions, Debug (Devtron provides a dedicated terminal for each node), Cordon, Drain, Edit the taints, and Create & delete Resources.
Along with the above operations, the Node Overview tab shows resource consumption by the node, along with the pods running on the specific node.
Devtron’s Kubernetes dashboard also has a fully customizable monitoring dashboard. This dashboard can be used to fetch and visualize custom metrics from Prometheus and Grafana dashboards. The layout can be customized as you wish, and the metrics are embedded using iframes.
The Namespace tab of Devtron’s Resource Browser lists out all namespaces from specific Kubernetes clusters. It allows us to perform actions over the namespace like visualize and edit live Manifest, check for namespace events, and Delete namespace.
The Resource Browser of Devtron provides a lot more capabilities compared to KubeApps. Unlike KubeApps where we can only exec inside the running pod, Devtron can launch a cluster-wide terminal within which you can run kubectl commands, without leaving the Devtron dashboard. This helps reduce context switching. Within KubeApps, you constantly need to context switch to a CLI for performing any kubectl operations.
The Resource Browser of Devtron lists out all the workloads with visibility for their namespace, current status, restarts, IP, and node. The Resource Browser has a logical separation of different Kubernetes resources. As an example, the workloads category consists of K8s objects like CronJob, DeamonSet, Deployment, Job, Pod, ReplicaSet, Replication Controller, and StatefulSet. Other resources of the Kubernetes clusters are being listed accordingly under categories like Config & Storage, Networking, RBAC, Administration, Other Resources, and Custom Resources.
When debugging any cluster events, it can often get tricky to understand the problems that are occurring and what can be the action steps to resolve the problem. Devtron has a built-in AI tool that will analyze the events and help you gain actionable insights into warnings and error events.
On Workloads like Pods, it is possible to execute actions like visualizing and editing live Manifest, checking Events and logs, and exec into a particular container running in the pod. When you exec, you have the option to select the particular shell that you want to use and are familiar with.
Conclusion
In conclusion, KubeApps provides a focused solution for managing Helm charts, but its capabilities remain narrow in scope. Features like multi-cluster management, authentication setup, and role-based access control (RBAC) require additional effort to configure, which can become a bottleneck for teams looking to streamline their workflows. For organizations primarily working with Helm charts and requiring a lightweight tool, KubeApps may suffice, but it quickly falls short when scaling or diversifying workloads.
Devtron, by contrast, offers a holistic approach to Kubernetes management. It not only supports Helm chart deployments but also simplifies troubleshooting, integrates multiple clusters seamlessly, and enables SSO and RBAC configurations out of the box. Additionally, Devtron provides a visual interface for managing all cluster resources, making it a comprehensive platform for both developers and operators. These features empower teams to manage Kubernetes environments with greater control and confidence while reducing operational overhead.
Ultimately, while KubeApps fulfills basic needs, Devtron stands out as a versatile and scalable solution tailored for modern Kubernetes workflows. Whether you’re scaling clusters, managing complex deployments, or ensuring secure and efficient team collaboration, Devtron provides the tools you need to stay ahead in a dynamic cloud-native ecosystem.
