糟糕，我实现的k8s informer好像是依托答辩

终端1：kubectl proxy --port=8081  ： 在主机上8081端口代理aiserver服务

终端2： curl "http://localhost:8081/api/v1/namespaces/team-a/pods?watch=true"  --verbose

package main

import (
"fmt"
"time"

 v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/fields"
"k8s.io/client-go/kubernetes"
"k8s.io/client-go/tools/cache"
"k8s.io/client-go/tools/clientcmd"
)

func main() {
 config, _ := clientcmd.BuildConfigFromFlags("", "/home/user/.kube/config")
 clientset, _ := kubernetes.NewForConfig(config)

 podInformer := cache.NewSharedIndexInformer(
  cache.NewListWatchFromClient(
   clientset.CoreV1().RESTClient(),
   "pods",
   v1.NamespaceAll,
   fields.Everything(),
  ),
  &v1.Pod{},
  time.Minute*10, // resync 周期
  cache.Indexers{ // cache上的快速过滤器
   "byNode": func(obj interface{}) ([]string, error) {
    pod := obj.(*v1.Pod)
    return []string{pod.Spec.NodeName}, nil
   }},
 )

 podInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{
  DeleteFunc: func(obj interface{}) {
   pod := obj.(*v1.Pod)
   fmt.Printf("[DELETED] Pod: %s/%s\n", pod.Namespace, pod.Name)
  },
 })

 // 启动 informer (必须在独立goroutine中，因为Run方法是同步方法)
 stopCh := make(chan struct{})
 defer close(stopCh)
 go func() {
  fmt.Println("Starting PodInformer...")
  podInformer.Run(stopCh) // 同步方法，会阻塞直到 stopCh 关闭
  fmt.Println("PodInformer stopped")
 }()

 //  等待缓存同步就绪
if !cache.WaitForCacheSync(stopCh, podInformer.HasSynced) {
  panic("failed to wait for cache sync")
 }
 <-stopCh
}

type PodController struct {
 clientset kubernetes.Interface
 queue     workqueue.TypedRateLimitingInterface[string]
 informer  cache.SharedIndexInformer
 indexer   cache.Indexer
}

func NewPodController(clientset kubernetes.Interface) *PodController {
 // 创建 Pod informer
 podInformer := cache.NewSharedIndexInformer(
  cache.NewListWatchFromClient(
   clientset.CoreV1().RESTClient(),
   "pods",
   v1.NamespaceAll,
   fields.Everything(),
  ),
  &v1.Pod{},
  time.Minute*10, // resync 周期
  cache.Indexers{
   "byNode": func(obj interface{}) ([]string, error) {
    pod := obj.(*v1.Pod)
    return []string{pod.Spec.NodeName}, nil
   }},
 )

 // 创建控制器
 controller := &PodController{
  clientset: clientset,
  queue: workqueue.NewTypedRateLimitingQueue(
   workqueue.DefaultTypedControllerRateLimiter[string]( "string"),
  ),
  informer: podInformer,
  indexer:  podInformer.GetIndexer(),
 }

 // 注册事件处理器
 podInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{
  AddFunc:    controller.handleAdd,
  UpdateFunc: controller.handleUpdate,
  DeleteFunc: controller.handleDelete,
 })

return controller
}

func (c *PodController) handleAdd(obj interface{}) {
 key, err := cache.MetaNamespaceKeyFunc(obj)
 if err != nil {
  klog.Errorf("Couldn't get key for object %+v: %v", obj, err)
  return
 }
 c.queue.Add(key)
}

func (c *PodController) Run(workers int, stopCh <-chan struct{}) {
 defer c.queue.ShutDown()
 klog.Info("Starting Pod controller")
 go c.informer.Run(stopCh)

 if !cache.WaitForCacheSync(stopCh, c.informer.HasSynced) {
     klog.Error("Timed out waiting for caches to sync")
    return
 }
 for i := 0; i < workers; i++ {
    go wait.Until(c.runWorker, time.Second, stopCh)
 }
 <-stopCh
 klog.Info("Stopping Pod controller")
}

func (c *PodController) runWorker() {
  for c.processNextWorkItem() {
  }
}

func (c *PodController) processNextWorkItem() bool {
 key, quit := c.queue.Get()
 if quit {
  return false
 }

 defer c.queue.Done(key)

 err := c.syncPod(key)
 if err != nil {
   klog.Errorf("Error syncing pod %s: %v", key, err)
   c.queue.AddRateLimited(key)
   return true
 }

 c.queue.Forget(key)
 return true
}

func main() {
 // 创建 clientset
 // config, _ := rest.InClusterConfig()

 homepath := homedir.HomeDir()
 kubeconfig := filepath.Join(homepath, ".kube", "config")
 config, err := clientcmd.BuildConfigFromFlags("", kubeconfig) // 集群外认证访问 apiserver
 if err != nil {
   klog.Errorf("Error building kubeconfig: %v", err)
  }
  clientset, _ := kubernetes.NewForConfig(config)

  controller := NewPodController(clientset)
  stopCh := make(chan struct{})
  controller.Run(3, stopCh)
}

 item := QueueItem{
        Key:     fmt.Sprintf("%s/%s", pod.Namespace, pod.Name),
        Version: pod.ResourceVersion,
        Status ： pod.Status，
    }