Pricing Login
Interactive demos

Click through interactive platform demos now.

Live demo, real expert

Schedule a platform demo with a Sumo Logic expert.

Start free trial
Back to blog results

September 30, 2020 By Sumo Logic

Kubernetes Dashboard

Kubernetes, as a platform, is a comprehensive set of tools for orchestrating containers at scale. It consists of a modular architecture of specific components with a defined purpose. For example, the scheduler finds the ideal match for a particular pod and the kube-proxy manages the networking between the nodes and the master.

One of the most useful components is the Kube API server, which is the main interaction point between the master and the external world. It offers a complete set of REST operations from which all other components interface with each other. Having a REST server is also useful for offering Dashboards for managing Kubernetes via a UI. The official Kubernetes team maintains a Web UI Dashboard, which is a quick and convenient way to manage and troubleshoot cluster resources.

[Watch: Kubernetes Observability]

Below, we will discuss how to deploy and utilize a standard Kubernetes Dashboard and show the benefits that a Sumologic kubernetes dashboard provides.

Deploying and Utilizing the Dashboard UI

Surprisingly enough, the dashboard itself is a container that accesses the cluster information from within the cluster. For Kubernetes, it is just another resource it needs to manage.

To install it, we need to apply the recommended deployment descriptor file:

$ kubectl apply -f

There is also an alternative deployment path with less secure endpoints:

Take a look at those yaml files before executing the plan, as it gives you a clearer picture of what we are going to deploy:

  • A namespace: kubernetes-dashboard
  • A service account for the dashboard
  • A service from port 8000:8000
  • A secret
  • A Config map
  • An RBAC role and RoleBinding
  • The main image deployment
  • The metrics scraper deployment

[Watch: Advanced Metrics in Kubernetes]

Once the deployment completes, you can establish a proxy connection with the cluster, using the following command:

$ kubectl proxy

Starting to serve on

Now navigate to:


You will be presented with this login screen:

We need to select Token here, and use the secret value as stored in the cluster. For convenience, I’ve listed a small script that we use to search for the secret token name and copy the token to the clipboard:

get_k8s_secret() {
echo "query:"
echo " namespace: $k8s_namespace"
echo " query_name: $query_name"
secret_token_name_output=$(kubectl -n "$k8s_namespace" get secret | grep "$query_name" | awk '{print $1}')
if [[ -z "$secret_token_name_output" ]]; then
echo "message: Token name not found"
secret_token_name=(${secret_token_name_output//"\n"/ })
if [[ "${#secret_token_name[@]}" -gt 1 ]]; then
echo "message: More than one token found"
echo "secret_names: ${secret_token_name[@]}"
k8s_secret=$(kubectl -n "$k8s_namespace" describe secret "$secret_token_name")
token=$(echo "$k8s_secret" | grep -E '^token:' | cut -f2 -d':' | xargs echo -n)
echo "message: Token found! This is copied to your clipboard"
echo "secret_name: $secret_token_name"
echo "secret_token: $token"
$(echo "$token" | pbcopy)
for i in "$@"
case $i in
shift # past argument=value
shift # past argument=value
shift # help
shift # help
# unknown option
if [[ "$DASHBOARD_DEFAULT" ]] ; then
get_k8s_secret kube-system kubernetes-dashboard-token
elif [[ "$NAMESPACE" && "$QUERY" ]] ; then
get_k8s_secret "$NAMESPACE" "$QUERY"
elif [[ -z "$DASHBOARD_DEFAULT" || -z "$NAMESPACE" || -z "$QUERY" || "$HELP" ]] ; then
echo -e "You need to set some of the following paramaters:\n"
echo "Usage: $0"
echo -e "\t-d - The Default Dashboard query. The following parameters are set -n 'kube-system' -q 'kubernetes-dashboard-token'"
echo -e "\t-n - The kubernetes namespace"
echo -e "\t-q - The kubernetes secret name to query"
echo -e "\t-h - Help"
exit 1

Here is how we use it:

-d - The Default Dashboard query. The following parameters are set -n 'kube-system' -q 'kubernetes-dashboard-token'
-n - The kubernetes namespace
-q - The kubernetes secret name to query
-h - Help

That should print:

namespace: kube-system
query_name: kubernetes-dashboard-token
message: Token found! This is copied to your clipboard
secret_name: kubernetes-dashboard-token-wxyz
secret_token: eyJhbGciOiJSUzI1NiIsImt…

Once we login we should be able to view the main dashboard page:

Now let’s explore the dashboard in detail.

Navigating through the Dashboard UI

Navigating through the Dashboard layout should be intuitive. There are main sections on the right-hand side for Cluster Management, Workloads, Service Discovery, Config, Storage and Settings.

Each section expands to subsections where we can select individual resources that we can manage. For example:

  • We can easily switch namespaces using the dropdown selection option:
  • We can see all the available nodes from Cluster-> Nodes
  • We can see the list of all pods, and filter by pod label from Workloads->Pods
  • We can see the list of all config maps, and filter by pod label from Config and Storage >Config Maps
  • We can perform additional actions for each item in the list by clicking on the vertical dotted icons on the right-hand side. For example, we have the option to see the logs or scale the deployment:

That concludes the basic navigation of the dashboard. Let’s see how we can create a new resource using the UI this time, and deploy it into the cluster.

Deploying Containerized Applications

We can create a new resource deployment using the plus (+) button on the upper right-hand corner of the screen:

We can then have various options to describe our deployment such as text, file or a generic form. Let’s choose the last option and follow the form steps to deploy a Redis server in our cluster.

If you click on the show advanced options button you can fill in additional properties regarding the deployment:

Once you are ready, click on the Deploy button. You should be able to see the deployment information and its status:

Once the deployment is successful, we should be able to connect to the redis server from within the cluster. For example:

$ kubectl exec -it redisdemo-598d696fb6-mfmhz /bin/sh
/data # ps
1 redis 0:00 redis-server
16 root 0:00 /bin/sh
21 root 0:00 ps
/data # redis-cli> INFO
# Server
os:Linux 4.14.152-127.182.amzn2.x86_64 x86_64

Once we are finished working with this example, we can destroy it using the trash icon:

Kubernetes Dashboards with Sumo Logic

The official Kubernetes Dashboard is a valuable tool when we want to quickly manage and monitor our Cluster. However, out-of-the-box it is very limited, and it quickly becomes a second or third choice. For those that want something more advanced and need enterprise-level support, you can leverage the new Sumo Logic Dashboards for Kubernetes.

Among the many features, they offer integration with the existing Sumo logic Dashboards, so we don’t have to switch tabs and places to monitor our cluster. We have numerous collection options and custom widgets. There are also additional sections, such as a dedicated security overview. This is more favorable than the stock dashboard, which has a set widget layout and looks more primitive.

The benefits of using a custom Dashboard for Kubernetes like Sumo Logic Dashboards, is the improved visibility and more streamlined experience. We have more options for customization coupled with the enterprise-level of support for new features that makes the product more aligned with the business needs.

Complete visibility for DevSecOps

Reduce downtime and move from reactive to proactive monitoring.

Navigate Kubernetes with Sumo Logic

Monitor, troubleshoot and secure your Kubernetes clusters with Sumo Logic cloud-native SaaS analytics solution for K8s.

Learn more

Sumo Logic

More posts by Sumo Logic.

People who read this also enjoyed