Install Lens Desktop – Kubernetes Cluster Management Tool

Lens Desktop is a graphical Kubernetes management tool that gives engineers a real-time view of clusters, workloads, logs, and metrics from a single application. It runs on Linux, macOS, and Windows, connects to any Kubernetes cluster through standard kubeconfig files, and provides a built-in terminal, Helm chart management, and resource monitoring without requiring additional plugins.

This guide covers how to install Lens Desktop on all major platforms, connect it to your Kubernetes clusters, navigate the UI for day-to-day operations, manage Helm charts, use the built-in terminal, and take advantage of productivity features like hotkeys, extensions, and multi-cluster management.

Prerequisites

• A workstation running Linux (Ubuntu, Debian, Fedora, RHEL), macOS, or Windows
• At least one running Kubernetes cluster (any distribution – k3s, kubeadm, EKS, GKE, AKS, etc.)
• A valid kubeconfig file with cluster access credentials
• Network connectivity from your workstation to the Kubernetes API server (default port 6443/TCP)
• sudo/admin access on your workstation for installation

If you do not have a Kubernetes cluster yet, you can quickly set one up using K3s on Ubuntu or use kubeadm for a production-grade deployment.

What is Lens Desktop?

Lens Desktop (previously known as Lens IDE) is an Electron-based desktop application built specifically for Kubernetes cluster management. It was originally created by Mirantis and has become one of the most popular Kubernetes GUI tools with millions of users worldwide.

Key capabilities of Lens Desktop include:

• Multi-cluster management – connect and switch between multiple Kubernetes clusters from a single window
• Real-time resource monitoring – built-in Prometheus integration for CPU, memory, network, and disk metrics
• Workload management – view, edit, scale, and delete Pods, Deployments, StatefulSets, DaemonSets, Jobs, and CronJobs
• Built-in terminal – context-aware kubectl terminal that matches the API version of the connected cluster
• Log streaming – view pod logs in real-time with search and filtering
• Helm chart management – browse, install, upgrade, and remove Helm releases directly from the UI
• RBAC visualization – inspect Roles, ClusterRoles, RoleBindings, and ServiceAccounts
• Extension ecosystem – extend functionality with community and first-party extensions

Lens reads your existing kubeconfig files and requires no server-side agents or modifications to your clusters.

Step 1: Install Lens Desktop on Linux

Lens Desktop is available for Linux through several methods: Snap, AppImage, .deb package, and .rpm package. Choose the method that fits your distribution.

Method 1: Install Lens using Snap (Ubuntu/Debian/Fedora)

Snap is the simplest way to install Lens on any Linux distribution that supports snapd. First, make sure snapd is installed and running.

On Ubuntu and Debian systems:

$ sudo apt update
$ sudo apt install -y snapd

On Fedora:

$ sudo dnf install -y snapd

On RHEL and CentOS Stream:

$ sudo dnf install -y epel-release
$ sudo dnf install -y snapd

Enable the snapd socket and create the classic snap symlink:

$ sudo systemctl enable --now snapd.socket
$ sudo ln -s /var/lib/snapd/snap /snap

Log out and back in (or reboot) to ensure snap paths are loaded. Then install Lens:

$ sudo snap install lens --classic

Verify the installation:

$ snap list lens
Name  Version    Rev   Tracking       Publisher    Notes
lens  2024.11.x  xxx   latest/stable  mirantis     classic

Method 2: Install Lens using .deb Package (Ubuntu/Debian)

Download the latest .deb package from the Lens Desktop download page and install it with apt:

$ curl -fSL -o lens-desktop.deb "https://api.k8slens.dev/binaries/latest/Lens-latest.amd64.deb"
$ sudo apt install -y ./lens-desktop.deb

This installs Lens and handles all dependencies automatically. Launch it from your applications menu or run lens-desktop from the terminal.

Method 3: Install Lens using .rpm Package (Fedora/RHEL)

For RPM-based distributions, download the .rpm package:

$ curl -fSL -o lens-desktop.rpm "https://api.k8slens.dev/binaries/latest/Lens-latest.x86_64.rpm"
$ sudo dnf install -y ./lens-desktop.rpm

Method 4: Install Lens using AppImage (Any Linux)

AppImage works on any Linux distribution without installation. Download the AppImage file:

$ curl -fSL -o Lens-Desktop.AppImage "https://api.k8slens.dev/binaries/latest/Lens-latest.x86_64.AppImage"
$ chmod +x Lens-Desktop.AppImage

Run it directly:

$ ./Lens-Desktop.AppImage

For a permanent setup, move the AppImage to a standard location:

$ sudo mv Lens-Desktop.AppImage /usr/local/bin/lens-desktop
$ lens-desktop

Step 2: Install Lens Desktop on macOS

On macOS, you can install Lens Desktop using Homebrew or by downloading the .dmg installer directly.

Method 1: Install with Homebrew

Homebrew is the recommended method on macOS:

$ brew install --cask lens

This downloads and installs Lens to your Applications folder. Launch it from Spotlight or the Applications directory.

Method 2: Install from .dmg File

Download the .dmg file from k8slens.dev, open it, and drag Lens to the Applications folder. Both Intel and Apple Silicon builds are available.

Step 3: Install Lens Desktop on Windows

Download the Windows installer (.exe) from the Lens Desktop download page. Run the installer and follow the setup wizard. Lens will be added to your Start menu.

Alternatively, install via Windows Package Manager:

$ winget install Mirantis.Lens

Or using Chocolatey:

$ choco install lens

Step 4: Add Kubernetes Clusters to Lens

Lens connects to Kubernetes clusters using standard kubeconfig files. By default, it reads ~/.kube/config on Linux and macOS, or %USERPROFILE%\.kube\config on Windows.

Auto-detected Clusters

When you launch Lens for the first time, it scans your default kubeconfig and lists all available contexts. Click the catalog icon in the left sidebar and you will see your clusters listed. Click a cluster to connect.

Adding a Cluster from a Custom Kubeconfig

If your kubeconfig is stored in a non-default location, add it through File > Add Cluster (or press Ctrl+Shift+A on Linux/Windows, Cmd+Shift+A on macOS). You can either browse for a kubeconfig file or paste the YAML content directly.

A typical kubeconfig looks like this:

apiVersion: v1
kind: Config
clusters:
- cluster:
    certificate-authority-data: BASE64_ENCODED_CA
    server: https://192.168.1.100:6443
  name: my-cluster
contexts:
- context:
    cluster: my-cluster
    user: admin
  name: my-cluster-context
current-context: my-cluster-context
users:
- name: admin
  user:
    client-certificate-data: BASE64_ENCODED_CERT
    client-key-data: BASE64_ENCODED_KEY

Make sure the server field points to an IP or hostname reachable from your workstation. Port 6443/TCP must be open between your machine and the API server.

Copying Kubeconfig from a Remote Cluster

For clusters provisioned with kubeadm, the kubeconfig is at /etc/kubernetes/admin.conf. For K3s clusters, it is at /etc/rancher/k3s/k3s.yaml. Copy it to your local machine:

$ scp [email protected]:/etc/kubernetes/admin.conf ~/.kube/config

For K3s specifically:

$ scp [email protected]:/etc/rancher/k3s/k3s.yaml ~/.kube/config

After copying, edit the file and replace 127.0.0.1 or localhost in the server field with the actual IP address of your cluster node.

Step 5: Navigate the Lens Desktop UI

Once connected to a cluster, Lens presents a sidebar with organized sections for every Kubernetes resource type. Understanding this layout is essential for efficient cluster management.

Cluster Overview Dashboard

The main dashboard shows a high-level view of cluster health: node status, CPU and memory utilization graphs, pod distribution, and any warning events. This is the first thing you see after connecting.

Nodes View

Click Nodes in the sidebar to see all cluster nodes with their status, roles, Kubernetes version, OS image, kernel version, and resource allocation. Click any node to view detailed metrics, conditions, labels, annotations, and running pods on that node.

Workloads Section

The Workloads section contains sub-menus for Pods, Deployments, StatefulSets, DaemonSets, ReplicaSets, Jobs, and CronJobs. Each view lists the resources with their status, namespace, age, and key details.

From the Pods view, click the three-dot menu on any pod to access logs, open a shell, edit the YAML, or delete the pod. The log viewer supports real-time streaming, text search, and downloading logs to a file.

To scale a Deployment, click on it, then click the scale icon or edit the replica count directly. Changes apply immediately to the cluster.

Network Resources

The Network section displays Services, Endpoints, Ingresses, and Network Policies. Click any Service to see its type (ClusterIP, NodePort, LoadBalancer), selector labels, ports, and connected pods. For Ingresses, you can see the routing rules, backends, and TLS configuration.

Storage Resources

Under Storage, you will find Persistent Volumes (PV), Persistent Volume Claims (PVC), and Storage Classes. This view helps you track which volumes are bound, available, or released. Click a PVC to see its capacity, access modes, and the pod consuming it. If your cluster uses dynamic volume provisioning, Storage Classes are listed here as well.

RBAC and Access Control

The Access Control section (also labeled RBAC in some Lens versions) lists ServiceAccounts, Roles, ClusterRoles, RoleBindings, and ClusterRoleBindings. This is useful for auditing who has access to what in the cluster. Click any Role to inspect its rules, including which API groups, resources, and verbs are permitted.

Step 6: Use the Built-in Terminal

Lens includes a built-in terminal that is context-aware. It automatically configures kubectl to point at the currently selected cluster with the correct API version. Open it by clicking the terminal icon at the bottom of the window or pressing Ctrl+` (backtick) on Linux/Windows or Cmd+` on macOS.

The terminal is a full shell environment where you can run any kubectl command:

$ kubectl get pods --all-namespaces
NAMESPACE     NAME                                     READY   STATUS    RESTARTS   AGE
kube-system   coredns-7b98449c4-xj5kq                 1/1     Running   0          2d
kube-system   metrics-server-668d979685-w7dnf          1/1     Running   0          2d
default       nginx-deployment-6b474476c4-7xqmf        1/1     Running   0          1d

You can also open a shell directly into a pod from the Pods view. Click the three-dot menu on any pod and select Shell. This opens an interactive terminal session inside the container.

For those who work heavily with kubectl on the command line, check out our kubectl productivity guide for tips that also apply within the Lens terminal.

Step 7: Manage Helm Charts in Lens

Lens has built-in Helm chart management, allowing you to browse, install, upgrade, and delete Helm releases without leaving the application.

Browse and Install Charts

Navigate to Helm > Charts in the sidebar. Lens shows charts from all configured Helm repositories. Use the search bar to find a chart, then click it to see the description, available versions, and default values.

To install a chart:

1. Click the chart name to open its details
2. Select the version you want to deploy
3. Choose the target namespace
4. Edit the values YAML as needed
5. Click Install

Manage Installed Releases

Under Helm > Releases, you see all deployed Helm releases across namespaces. Click any release to view its revision history, current values, and the resources it created. From here, you can upgrade to a newer chart version, roll back to a previous revision, or delete the release entirely.

For more details on Helm usage, see our guide on installing and using Helm 3 on Kubernetes.

Add Custom Helm Repositories

To add a custom Helm repository, open the terminal and run:

$ helm repo add bitnami https://charts.bitnami.com/bitnami
$ helm repo update

The new repository charts will appear in the Lens Charts browser after a refresh.

Step 8: Enable Resource Monitoring

Lens can display CPU, memory, network, and filesystem metrics for nodes and pods. It supports two Prometheus configurations: the built-in Lens metrics stack, or an existing Prometheus deployment in your cluster.

Install Built-in Metrics

If you see “Metrics are not available” on the cluster dashboard, right-click the cluster icon in the sidebar and select Settings. Under the Metrics section, select Lens as the Prometheus installation method and click Apply. Lens deploys a lightweight Prometheus instance into the lens-metrics namespace.

After a few seconds, the dashboard populates with real-time graphs for node and pod resource consumption.

Use an Existing Prometheus Instance

If your cluster already runs Prometheus, select Custom Prometheus in the metrics settings and provide the service address. The format is typically:

prometheus-operated.monitoring.svc.cluster.local:9090

Adjust the namespace and service name to match your actual Prometheus deployment.

Step 9: Multi-Cluster Management

Lens excels at managing multiple Kubernetes clusters simultaneously. Each cluster you add appears in the left sidebar catalog. Switch between clusters with a single click – no need to manually change kubectl contexts or juggle multiple terminal windows.

Organizing Clusters with Hotbar

The Hotbar at the bottom of the sidebar lets you pin frequently accessed clusters for quick switching. Drag a cluster from the catalog to the Hotbar, and it stays accessible regardless of which view you are in.

Merging Multiple Kubeconfig Files

If you manage clusters from different sources (EKS, GKE, on-prem kubeadm, K3s), you can merge kubeconfigs into a single file or point Lens to multiple kubeconfig paths. Set the KUBECONFIG environment variable to include all paths:

$ export KUBECONFIG=~/.kube/config:~/.kube/eks-config:~/.kube/gke-config

Lens reads all contexts from the merged configuration. For managing multiple clusters with kubectl directly, see our guide on managing multiple Kubernetes clusters with kubectx.

Step 10: Lens Extensions and Plugins

Lens supports extensions that add features to the application. Extensions can add new sidebar items, custom resource views, and integrations with external tools.

Installing Extensions

Navigate to File > Extensions (or Lens > Extensions on macOS). You can install extensions from:

• NPM registry – paste the npm package name (e.g., @aquasecurity/trivy-operator-lens-extension)
• Local .tgz file – for custom or private extensions, upload the tarball directly
• URL – provide a direct URL to the extension package

Popular Lens Extensions

Some widely used Lens extensions include:

• Trivy Operator – view vulnerability scan results for container images directly in the pod details
• Starboard – security scanning and compliance reports within the Lens UI
• Resource Map – visual dependency graph showing how resources are connected
• Certificate Info – displays TLS certificate details for secrets

Lens Desktop vs OpenLens Comparison

OpenLens is the open-source upstream project that Lens Desktop is built from. Understanding the differences helps you choose the right tool for your workflow.

Feature	Lens Desktop (Mirantis)	OpenLens (Community)
License	Proprietary (free tier available)	MIT open-source
Lens Account Required	Yes (free or paid)	No
Built-in Extensions	Yes (bundled)	Manual installation
Prometheus Integration	Built-in with one-click setup	Manual configuration
Auto-updates	Yes	Manual builds or community packages
Extension Marketplace	Yes	Limited
Telemetry	Yes (can be disabled)	No
Support	Commercial support available	Community only

Lens Desktop is the better choice for teams that want a maintained, supported product with built-in integrations. OpenLens suits users who prefer a fully open-source tool and are comfortable building from source or using community-maintained packages.

Note that as of late 2023, the OpenLens project repository has had reduced activity. Check the GitHub repository for current status before committing to OpenLens for production use.

Keyboard Shortcuts and Productivity Tips

Lens Desktop supports keyboard shortcuts that speed up navigation significantly. Here are the most useful ones:

Action	Linux/Windows	macOS
Open command palette	Ctrl+Shift+P	Cmd+Shift+P
Toggle terminal	Ctrl+`	Cmd+`
Add cluster	Ctrl+Shift+A	Cmd+Shift+A
Switch cluster	Ctrl+Shift+S	Cmd+Shift+S
Search resources	Ctrl+K	Cmd+K
Zoom in/out	Ctrl++ / Ctrl+-	Cmd++ / Cmd+-
Reset zoom	Ctrl+0	Cmd+0

Additional productivity tips:

• Use the command palette (Ctrl+Shift+P) to quickly jump to any resource type, cluster, or setting without clicking through menus
• Pin clusters to the Hotbar for one-click switching between your most-used environments
• Right-click any resource to get quick actions like edit, delete, or view logs
• Use namespace filtering at the top of the cluster view to focus on specific namespaces
• Bookmark important resources by starring them in the catalog for fast access
• Set custom Prometheus queries in the metrics settings to track application-specific metrics

Troubleshooting Common Issues

Lens Cannot Connect to Cluster

Verify your kubeconfig is valid by running kubectl outside of Lens:

$ kubectl cluster-info
Kubernetes control plane is running at https://192.168.1.100:6443

If kubectl works but Lens does not, check that no proxy or VPN settings are interfering. Lens respects the HTTPS_PROXY and NO_PROXY environment variables.

Metrics Not Showing

If the built-in Lens metrics stack fails to deploy, check that your cluster has enough resources (at least 256MB free memory). You can also verify that the lens-metrics namespace was created:

$ kubectl get pods -n lens-metrics
NAME                          READY   STATUS    RESTARTS   AGE
prometheus-0                  1/1     Running   0          5m

If the Prometheus pod is stuck in Pending, check for resource constraints or missing storage classes.

Lens on Linux Shows Blank Screen

If Lens starts but shows a blank window, try disabling GPU acceleration:

$ lens-desktop --disable-gpu

This is common on systems with older GPU drivers or when running inside a virtual machine.

Conclusion

Lens Desktop provides a single interface for managing Kubernetes clusters across Linux, macOS, and Windows. With built-in monitoring, Helm chart management, RBAC inspection, and a context-aware terminal, it eliminates the need to constantly switch between kubectl, dashboard UIs, and monitoring tools.

For production environments, combine Lens with proper RBAC policies to limit what each team member can see and modify. Use the built-in metrics for quick troubleshooting, but maintain a dedicated monitoring stack (Prometheus + Grafana) for long-term observability and alerting.

Related Guides

• Install Kubernetes Cluster on Ubuntu using K3s
• How To Install and Use Helm 3 on Kubernetes Cluster
• Managing Multiple Kubernetes Clusters using kubectx
• Become a Kubernetes Pro with this kubectl Guide
• Install Kubernetes Cluster on Ubuntu using kubeadm