Kubernetes support

* Total CPU and Memory usage for the entire cluster
* Total CPU and Memory usage for kubernetes pods
* Service discovery via annotations on ingress
* No storage stats yet
* No network stats yet

src/pages/api/kubernetes/stats/[...service].js

@@ -0,0 +1,79 @@
+import { CoreV1Api, Metrics } from "@kubernetes/client-node";
+
+import getKubeConfig from "../../../../utils/config/kubernetes";
+import { parseCpu, parseMemory } from "../../../../utils/kubernetes/kubernetes-utils";
+
+export default async function handler(req, res) {
+  const APP_LABEL =  "app.kubernetes.io/name";
+  const { service } = req.query;
+
+  const [namespace, appName] = service;
+  if (!namespace && !appName) {
+    res.status(400).send({
+      error: "kubernetes query parameters are required",
+    });
+    return;
+  }
+  const labelSelector = `${APP_LABEL}=${appName}`;
+
+  try {
+    const kc = getKubeConfig();
+    const coreApi = kc.makeApiClient(CoreV1Api);
+    const metricsApi = new Metrics(kc);
+    const podsResponse = await coreApi.listNamespacedPod(namespace, null, null, null, null, labelSelector);
+    const pods = podsResponse.body.items;
+
+    if (pods.length === 0) {
+      res.status(200).send({
+        error: "not found",
+      });
+      return;
+    }
+
+    let cpuLimit = 0;
+    let memLimit = 0;
+    pods.forEach((pod) => {
+      pod.spec.containers.forEach((container) => {
+        if (container?.resources?.limits?.cpu) {
+          cpuLimit += parseCpu(container?.resources?.limits?.cpu);
+        }
+        if (container?.resources?.limits?.memory) {
+          memLimit += parseMemory(container?.resources?.limits?.memory);
+        }
+      });
+    });
+
+    const stats = await pods.map(async (pod) => {
+      let depMem = 0;
+      let depCpu = 0;
+      const podMetrics = await metricsApi.getPodMetrics(namespace, pod.metadata.name);
+      podMetrics.containers.forEach((container) => {
+        depMem += parseMemory(container.usage.memory);
+        depCpu += parseCpu(container.usage.cpu);
+      });
+      return {
+        mem: depMem,
+        cpu: depCpu
+      }
+    }).reduce(async (finalStats, podStatPromise) => {
+      const podStats = await podStatPromise;
+      return {
+        mem: finalStats.mem + podStats.mem,
+        cpu: finalStats.cpu + podStats.cpu
+      };
+    });
+    stats.cpuLimit = cpuLimit;
+    stats.memLimit = memLimit;
+    stats.cpuUsage = stats.cpu / cpuLimit;
+    stats.memUsage = stats.mem / memLimit;
+
+    res.status(200).json({
+      stats,
+    });
+  } catch (e) {
+    console.log("error", e);
+    res.status(500).send({
+      error: "unknown error",
+    });
+  }
+}

src/pages/api/kubernetes/status/[...service].js

@@ -0,0 +1,42 @@
+import { CoreV1Api } from "@kubernetes/client-node";
+
+import getKubeConfig from "../../../../utils/config/kubernetes";
+
+export default async function handler(req, res) {
+  const APP_LABEL =  "app.kubernetes.io/name";
+  const { service } = req.query;
+
+  const [namespace, appName] = service;
+  if (!namespace && !appName) {
+    res.status(400).send({
+      error: "kubernetes query parameters are required",
+    });
+    return;
+  }
+  const labelSelector = `${APP_LABEL}=${appName}`;
+
+  try {
+    const kc = getKubeConfig();
+    const coreApi = kc.makeApiClient(CoreV1Api);
+    const podsResponse = await coreApi.listNamespacedPod(namespace, null, null, null, null, labelSelector);
+    const pods = podsResponse.body.items;
+
+    if (pods.length === 0) {
+      res.status(200).send({
+        error: "not found",
+      });
+      return;
+    }
+
+    // at least one pod must be in the "Running" phase, otherwise its "down"
+    const runningPod = pods.find(pod => pod.status.phase === "Running");
+    const status = runningPod ? "running" : "down";
+    res.status(200).json({
+      status
+    });
+  } catch {
+    res.status(500).send({
+      error: "unknown error",
+    });
+  }
+}

src/pages/api/widgets/kubernetes.js

@@ -0,0 +1,72 @@
+import { CoreV1Api, Metrics } from "@kubernetes/client-node";
+
+import getKubeConfig from "../../../utils/config/kubernetes";
+import { parseCpu, parseMemory } from "../../../utils/kubernetes/kubernetes-utils";
+
+export default async function handler(req, res) {
+  const { type } = req.query;
+
+  const kc = getKubeConfig();
+  const coreApi = kc.makeApiClient(CoreV1Api);
+  const metricsApi = new Metrics(kc);
+
+  const nodes = await coreApi.listNode();
+  const nodeCapacity = new Map();
+  let cpuTotal = 0;
+  let cpuUsage = 0;
+  let memTotal = 0;
+  let memUsage = 0;
+
+  nodes.body.items.forEach((node) => {
+    nodeCapacity.set(node.metadata.name, node.status.capacity);
+    cpuTotal += Number.parseInt(node.status.capacity.cpu, 10);
+    memTotal += parseMemory(node.status.capacity.memory);
+  });
+
+  const nodeMetrics = await metricsApi.getNodeMetrics();
+  const nodeUsage = new Map();
+  nodeMetrics.items.forEach((metrics) => {
+    nodeUsage.set(metrics.metadata.name, metrics.usage);
+    cpuUsage += parseCpu(metrics.usage.cpu);
+    memUsage += parseMemory(metrics.usage.memory);
+  });
+
+  if (type === "cpu") {
+    return res.status(200).json({
+      cpu: {
+        usage: (cpuUsage / cpuTotal) * 100,
+        load: cpuUsage
+      }
+    });
+  }
+  // Maybe Storage CSI can provide this information
+  // if (type === "disk") {
+  //   if (!existsSync(target)) {
+  //     return res.status(404).json({
+  //       error: "Target not found",
+  //     });
+  //   }
+  //
+  //   return res.status(200).json({
+  //     drive: await drive.info(target || "/"),
+  //   });
+  // }
+  //
+  if (type === "memory") {
+    const SCALE_MB = 1024 * 1024;
+    const usedMemMb = memUsage / SCALE_MB;
+    const totalMemMb = memTotal / SCALE_MB;
+    const freeMemMb = totalMemMb - usedMemMb;
+    return res.status(200).json({
+      memory: {
+        usedMemMb,
+        freeMemMb,
+        totalMemMb
+      }
+    });
+  }
+
+  return res.status(400).json({
+    error: "invalid type"
+  });
+}