feat: kube proxy

main.go

@@ -168,6 +168,9 @@ func setupAPIRouter(r *gin.Engine, cm *cluster.ClusterManager) {
 
 		api.GET("/image/tags", handlers.GetImageTags)
 
+		proxyHandler := handlers.NewProxyHandler()
+		proxyHandler.RegisterRoutes(api)
+
 		api.Use(middleware.RBACMiddleware())
 		resources.RegisterRoutes(api)
 	}

pkg/handlers/proxy_handler.go

@@ -0,0 +1,38 @@
+package handlers
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"github.com/zxh326/kite/pkg/cluster"
+	"github.com/zxh326/kite/pkg/kube"
+	"github.com/zxh326/kite/pkg/model"
+	"github.com/zxh326/kite/pkg/rbac"
+)
+
+type ProxyHandler struct{}
+
+func NewProxyHandler() *ProxyHandler {
+	return &ProxyHandler{}
+}
+
+func (h *ProxyHandler) RegisterRoutes(rg *gin.RouterGroup) {
+	rg.GET("/namespaces/:namespace/:kind/:name/proxy/*path", h.HandleProxy)
+}
+
+func (h *ProxyHandler) HandleProxy(c *gin.Context) {
+	cs := c.MustGet("cluster").(*cluster.ClientSet)
+	user := c.MustGet("user").(model.User)
+	kind := c.Param("kind")
+	if kind != "pods" && kind != "services" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid kind, must be 'pods' or 'services'"})
+		return
+	}
+	name := c.Param("name")
+	namespace := c.Param("namespace")
+	if !rbac.CanAccess(user, kind, "get", cs.Name, namespace) {
+		c.JSON(http.StatusForbidden, gin.H{"error": "forbidden"})
+		return
+	}
+	kube.HandleProxy(c, cs.K8sClient, kind, namespace, name, c.Param("path"))
+}

pkg/kube/proxy.go

@@ -0,0 +1,92 @@
+package kube
+
+import (
+	"context"
+	"errors"
+	"io"
+	"net/http"
+	"net/url"
+
+	"github.com/gin-gonic/gin"
+	"k8s.io/client-go/rest"
+	"k8s.io/klog/v2"
+)
+
+func HandleProxy(c *gin.Context, client *K8sClient, kind, namespace, name, proxyPath string) {
+	restConfig := rest.CopyConfig(client.Configuration)
+	httpClient, err := rest.HTTPClientFor(restConfig)
+	if err != nil {
+		klog.Errorf("failed to build kubernetes http client: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to initialize kubernetes client"})
+		return
+	}
+	targetURL, err := buildProxyURL(restConfig.Host, kind, namespace, name, proxyPath, c.Request.URL.RawQuery)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	req, err := http.NewRequestWithContext(c.Request.Context(), c.Request.Method, targetURL, c.Request.Body)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to create proxy request"})
+		return
+	}
+	req.Header = cloneHeader(c.Request.Header)
+	req.Header.Del("Authorization")
+	req.Header.Del("Cookie")
+
+	resp, err := httpClient.Do(req)
+
+	if err != nil {
+		klog.Errorf("proxy request failed: %v", err)
+		c.JSON(http.StatusBadGateway, gin.H{"error": "upstream request failed"})
+		return
+	}
+	defer func() {
+		_ = resp.Body.Close()
+	}()
+
+	copyHeader(c.Writer.Header(), resp.Header)
+	c.Writer.WriteHeader(resp.StatusCode)
+	if _, err := io.Copy(c.Writer, resp.Body); err != nil {
+		if !errors.Is(err, context.Canceled) {
+			klog.Errorf("failed to write proxy response: %v", err)
+		}
+	}
+}
+
+func buildProxyURL(host, kind, namespace, name, path, rawQuery string) (string, error) {
+	path, err := url.JoinPath(host, "api/v1/namespaces", namespace, kind, name, "proxy", path)
+	if err != nil {
+		return "", err
+	}
+
+	query, err := url.ParseQuery(rawQuery)
+	if err != nil {
+		return "", err
+	}
+	u, err := url.Parse(path)
+	if err != nil {
+		return "", err
+	}
+	u.RawQuery = query.Encode()
+	return u.String(), nil
+}
+
+func cloneHeader(h http.Header) http.Header {
+	cloned := make(http.Header, len(h))
+	for k, values := range h {
+		for _, v := range values {
+			cloned.Add(k, v)
+		}
+	}
+	return cloned
+}
+
+func copyHeader(dst, src http.Header) {
+	for k, values := range src {
+		for _, v := range values {
+			dst.Add(k, v)
+		}
+	}
+}

pkg/middleware/cluster.go

@@ -20,6 +20,9 @@ func ClusterMiddleware(cm *cluster.ClusterManager) gin.HandlerFunc {
 			if v, ok := c.GetQuery(ClusterNameHeader); ok {
 				clusterName = v
 			}
+			if clusterName == "" {
+				clusterName, _ = c.Cookie(ClusterNameHeader)
+			}
 		}
 		cluster, err := cm.GetClientSet(clusterName)
 		if err != nil {

ui/src/contexts/cluster-context.tsx

@@ -68,11 +68,13 @@ export const ClusterProvider: React.FC<{ children: React.ReactNode }> = ({
       const defaultCluster = clusters.find((c) => c.isDefault)
       if (defaultCluster) {
         setCurrentClusterState(defaultCluster.name)
+        cookieStore.set('x-cluster-name', defaultCluster.name)
         localStorage.setItem('current-cluster', defaultCluster.name)
       } else {
         // If no default cluster, use the first one
         setCurrentClusterState(clusters[0].name)
         localStorage.setItem('current-cluster', clusters[0].name)
+        cookieStore.set('x-cluster-name', clusters[0].name)
       }
     }
     if (
@@ -83,6 +85,7 @@ export const ClusterProvider: React.FC<{ children: React.ReactNode }> = ({
       // If current cluster is not in the list, reset it
       setCurrentClusterState(null)
       localStorage.removeItem('current-cluster')
+      cookieStore.delete('x-cluster-name')
     }
   }, [clusters, currentCluster])
 
@@ -92,6 +95,7 @@ export const ClusterProvider: React.FC<{ children: React.ReactNode }> = ({
         setIsSwitching(true)
         setCurrentClusterState(clusterName)
         localStorage.setItem('current-cluster', clusterName)
+        cookieStore.set('x-cluster-name', clusterName)
         setTimeout(async () => {
           await queryClient.invalidateQueries({
             predicate: (query) => {

ui/src/pages/pod-detail.tsx

@@ -1,5 +1,10 @@
 import { useEffect, useMemo, useState } from 'react'
-import { IconLoader, IconRefresh, IconTrash } from '@tabler/icons-react'
+import {
+  IconExternalLink,
+  IconLoader,
+  IconRefresh,
+  IconTrash,
+} from '@tabler/icons-react'
 import * as yaml from 'js-yaml'
 import { Pod } from 'kubernetes-types/core/v1'
 import { useTranslation } from 'react-i18next'
@@ -35,6 +40,7 @@ export function PodDetail(props: { namespace: string; name: string }) {
   const [refreshKey, setRefreshKey] = useState(0)
   const [isDeleteDialogOpen, setIsDeleteDialogOpen] = useState(false)
   const [isDeleting, setIsDeleting] = useState(false)
+
   const navigate = useNavigate()
   const { t } = useTranslation()
 
@@ -289,6 +295,37 @@ export function PodDetail(props: { namespace: string; name: string }) {
                           </p>
                         </div>
                       )}
+                      <div>
+                        <Label className="text-xs text-muted-foreground">
+                          Ports
+                        </Label>
+                        <div className="flex flex-wrap items-center gap-1">
+                          {pod.spec?.containers
+                            .flatMap((c) => c.ports || [])
+                            .map((port, index, array) => (
+                              <span
+                                key={`${port.containerPort}-${port.protocol}`}
+                              >
+                                <a
+                                  href={`/api/v1/namespaces/${namespace}/pods/${name}:${port.containerPort}/proxy/`}
+                                  target="_blank"
+                                  rel="noopener noreferrer"
+                                  className="font-mono text-blue-600 hover:text-blue-800 hover:underline inline-flex items-center gap-1"
+                                >
+                                  {port.name && `${port.name}:`}
+                                  {port.containerPort}
+                                  <IconExternalLink className="w-3 h-3" />
+                                </a>
+                                {index < array.length - 1 && ', '}
+                              </span>
+                            ))}
+                          {(!pod.spec?.containers ||
+                            pod.spec.containers.length === 0 ||
+                            pod.spec.containers.every(
+                              (c) => !c.ports || c.ports.length === 0
+                            )) && <span>No ports defined</span>}
+                        </div>
+                      </div>
                     </div>
                     <LabelsAnno
                       labels={pod.metadata?.labels || {}}

ui/src/pages/resource-detail.tsx

@@ -11,6 +11,7 @@ import { JobDetail } from './job-detail'
 import { NodeDetail } from './node-detail'
 import { PodDetail } from './pod-detail'
 import { SecretDetail } from './secret-detail'
+import { ServiceDetail } from './service-detail'
 import { SimpleResourceDetail } from './simple-resource-detail'
 import { StatefulSetDetail } from './statefulset-detail'
 
@@ -69,6 +70,8 @@ export function ResourceDetail() {
       return <SecretDetail namespace={namespace!} name={name} />
     case 'nodes':
       return <NodeDetail name={name} />
+    case 'services':
+      return <ServiceDetail namespace={namespace!} name={name} />
     default:
       return (
         <SimpleResourceDetail