kube-apiserver 初始命名空间实现方式-技术圈

在我们第 1 回仅启动一个 kube-apiserver 组件的情况下，Kubernetes 就创建了四个初始命名空间：

default：默认命名空间
kube-node-lease：用于保存与各个节点关联的 Lease（租约）对象
kube-public：所有（包括未经身份验证）的客户端都可以读取，主要用于集群内部共享资源
kube-system：用于 Kubernetes 系统创建资源，包括 Kubernetes 运行所需的核心组件

$ kubectl get ns
NAME                 STATUS   AGE
default              Active   2d22h
kube-node-lease      Active   2d22h
kube-public          Active   2d22h
kube-system          Active   2d22h

如果删除这四个初始命名空间：

$ kubectl delete ns default kube-node-lease kube-public kube-system
namespace "kube-node-lease" deleted
Error from server (Forbidden): namespaces "default" is forbidden: this namespace may not be deleted
Error from server (Forbidden): namespaces "kube-public" is forbidden: this namespace may not be deleted
Error from server (Forbidden): namespaces "kube-system" is forbidden: this namespace may not be deleted

会发现只有 kube-node-lease 允许删除，而且经过观察，删除后 1 分钟内，该命名空间也会自动重新创建：

$ kubectl get ns
NAME                 STATUS   AGE
default              Active   2d22h
kube-node-lease      Active   10s
kube-public          Active   2d22h
kube-system          Active   2d22h

这四个初始命名空间的维护工作，实际是由 GenericAPIServer 的 Hook 机制完成的。

在第 5 回启动 HTTP Server 的 NonBlockingRun 方法中：

// k8s.io/apiserver/pkg/server/genericapiserver.go
func (s preparedGenericAPIServer) NonBlockingRun(stopCh <-chan struct{}, shutdownTimeout time.Duration) (<-chan struct{}, <-chan struct{}, error) {
 // ...
 if s.SecureServingInfo != nil && s.Handler != nil {
  // 启动 HTTP Server
  stoppedCh, listenerStoppedCh, err = s.SecureServingInfo.Serve(s.Handler, shutdownTimeout, internalStopCh)
  // ...
 }

  // HTTP Server 退出通知
 go func() {
  <-stopCh
  close(internalStopCh)
 }()

 // 运行 Hook
 s.RunPostStartHooks(stopCh)
 // ...
}

当 HTTP Server 启动成功后，就会开始运行所有的 Hook ：

// k8s.io/apiserver/pkg/server/hooks.go

type PostStartHookFunc func(context PostStartHookContext) error

// Hook 实体
type postStartHookEntry struct {
 // hook 方法
 hook PostStartHookFunc
  // hook 方法的调用栈信息
 originatingStack string
 done chan struct{}
}

func (s *GenericAPIServer) RunPostStartHooks(stopCh <-chan struct{}) {
 s.postStartHookLock.Lock()
 defer s.postStartHookLock.Unlock()
 s.postStartHooksCalled = true

 context := PostStartHookContext{
  LoopbackClientConfig: s.LoopbackClientConfig,
  StopCh:               stopCh,
 }

 // postStartHooks 是一个保存所有 Hook 的 map[string]postStartHookEntry
  // 遍历所有 Hook 并运行其 hook 方法
 for hookName, hookEntry := range s.postStartHooks {
  go runPostStartHook(hookName, hookEntry, context)
 }
}

func runPostStartHook(name string, entry postStartHookEntry, context PostStartHookContext) {
 var err error
 func() {
  // don't let the hook *accidentally* panic and kill the server
  defer utilruntime.HandleCrash()
  // 运行其 hook 方法
  err = entry.hook(context)
 }()
 // if the hook intentionally wants to kill server, let it.
 if err != nil {
  klog.Fatalf("PostStartHook %q failed: %v", name, err)
 }
 close(entry.done)
}

在 s.postStartHooks 位置断点调试，可以看到当前版本一共有 24 种不同功能的 Hook ：

其中 start-system-namespaces-controller 便是本文的主角。

如果从 debug 的角度去找，可以看其对应的 hook 的调用栈信息定位到该 Hook 的创建位置：

或者继续跟随我的思路，来到第 3 回注册 /api/* 核心路由的 InstallLegacyAPI 方法：

// pkg/controlplane/instance.go
func (m *Instance) InstallLegacyAPI(c *completedConfig, restOptionsGetter generic.RESTOptionsGetter) error {
 // 创建 RESTStorage
 legacyRESTStorage, apiGroupInfo, err := legacyRESTStorageProvider.NewLegacyRESTStorage(c.ExtraConfig.APIResourceConfigSource, restOptionsGetter)


 controllerName := "bootstrap-controller"
 client := kubernetes.NewForConfigOrDie(c.GenericConfig.LoopbackClientConfig)
 // Kubernetes clusters contains the following system namespaces:
 // kube-system, kube-node-lease, kube-public, default
 // 注册 start-system-namespaces-controller Hook
 m.GenericAPIServer.AddPostStartHookOrDie("start-system-namespaces-controller", func(hookContext genericapiserver.PostStartHookContext) error {
  go systemnamespaces.NewController(client, c.ExtraConfig.VersionedInformers.Core().V1().Namespaces()).Run(hookContext.StopCh)
  return nil
 })

 bootstrapController, err := c.NewBootstrapController(legacyRESTStorage, client)
 if err != nil {
  return fmt.Errorf("error creating bootstrap controller: %v", err)
 }
 m.GenericAPIServer.AddPostStartHookOrDie(controllerName, bootstrapController.PostStartHook)
 m.GenericAPIServer.AddPreShutdownHookOrDie(controllerName, bootstrapController.PreShutdownHook)

 // 核心路由注册
 if err := m.GenericAPIServer.InstallLegacyAPIGroup(genericapiserver.DefaultLegacyAPIPrefix, &apiGroupInfo); err != nil {
  return fmt.Errorf("error in registering group versions: %v", err)
 }
 return nil
}

在 RESTStorage 创建之后，核心路由注册之前，注册了两个 Hook ：bootstrap-controller 和 start-system-namespaces-controller 。

Hook 注册的 AddPostStartHookOrDie 方法实际就是将 Hook 添加到 postStartHooks 中：

// k8s.io/apiserver/pkg/server/hooks.go
func (s *GenericAPIServer) AddPostStartHookOrDie(name string, hook PostStartHookFunc) {
 if err := s.AddPostStartHook(name, hook); err != nil {
  klog.Fatalf("Error registering PostStartHook %q: %v", name, err)
 }
}

func (s *GenericAPIServer) AddPostStartHook(name string, hook PostStartHookFunc) error {
 // ...
  // 添加到 postStartHooks map 中
 s.postStartHooks[name] = postStartHookEntry{hook: hook, originatingStack: string(debug.Stack()), done: done}

 return nil
}

因为 Hook 运行时实际是直接调用 hook 方法，所以重点还是各个 Hook 注册时自身所传入的 hook PostStartHookFunc 参数。

对于 start-system-namespaces-controller Hook 注册的 PostStartHookFunc 方法：

func(hookContext genericapiserver.PostStartHookContext) error {
  // 创建 start-system-namespaces-controller 并调用 Run 运行
  go systemnamespaces.NewController(client, c.ExtraConfig.VersionedInformers.Core().V1().Namespaces()).Run(hookContext.StopCh)
  return nil
}

该 controller 的实现很简单，我直接全部贴出来：

// pkg/controlplane/controller/systemnamespaces/system_namespaces_controller.go

// 创建 start-system-namespaces-controller
func NewController(clientset kubernetes.Interface, namespaceInformer coreinformers.NamespaceInformer) *Controller {
 // 需要维护的四个初始命名空间
 systemNamespaces := []string{metav1.NamespaceSystem, metav1.NamespacePublic, v1.NamespaceNodeLease, metav1.NamespaceDefault}
 // 定时周期为 1 分钟
 interval := 1 * time.Minute

 return &Controller{
  client:           clientset,
  namespaceLister:  namespaceInformer.Lister(),
  namespaceSynced:  namespaceInformer.Informer().HasSynced,
  systemNamespaces: systemNamespaces,
  interval:         interval,
 }
}

// 运行 start-system-namespaces-controller
func (c *Controller) Run(stopCh <-chan struct{}) {
 defer utilruntime.HandleCrash()
 defer klog.Infof("Shutting down system namespaces controller")

 klog.Infof("Starting system namespaces controller")

 if !cache.WaitForCacheSync(stopCh, c.namespaceSynced) {
  utilruntime.HandleError(fmt.Errorf("timed out waiting for caches to sync"))
  return
 }

 // 定时执行 c.sync 方法，定时周期为 1 分钟
 go wait.Until(c.sync, c.interval, stopCh)

 <-stopCh
}

func (c *Controller) sync() {
 // Loop the system namespace list, and create them if they do not exist
  // 遍历四个初始命名空间
 for _, ns := range c.systemNamespaces {
  // 如果需要则创建
  if err := c.createNamespaceIfNeeded(ns); err != nil {
   utilruntime.HandleError(fmt.Errorf("unable to create required kubernetes system Namespace %s: %v", ns, err))
  }
 }
}

func (c *Controller) createNamespaceIfNeeded(ns string) error {
 if _, err := c.namespaceLister.Get(ns); err == nil {
  // the namespace already exists
    // 命名空间已存在
  return nil
 }
 // 命名空间不存在，就去创建命名空间
 newNs := &v1.Namespace{
  ObjectMeta: metav1.ObjectMeta{
   Name:      ns,
   Namespace: "",
  },
 }
 _, err := c.client.CoreV1().Namespaces().Create(context.TODO(), newNs, metav1.CreateOptions{})
 if err != nil && errors.IsAlreadyExists(err) {
  err = nil
 }
 return err
}

这就是为什么启动一个 kube-apiserver 组件就创建了四个初始命名空间，并且 kube-node-lease 命名空间删除后 1 分钟内会自动重新创建的原因。

对于其它 23 种 Hook ，感兴趣也可以直接全局搜索 Hook name 快速定位到其注册位置去看。