前往小程序，Get更优阅读体验！
立即前往
文档建议反馈控制台
首页
学习
活动
专区
工具
TVP
最新优惠活动
文章/答案/技术大牛
发布
首页
学习
活动
专区
工具
TVP最新优惠活动
返回腾讯云官网
社区首页 >专栏 >Kubernetes之Informer机制详解

Kubernetes之Informer机制详解

作者头像
锅总
发布于 2024-06-28 13:31:51
1430
发布于 2024-06-28 13:31:51
举报
文章被收录于专栏：锅总锅总

本文尝试从Informer中的Lister、Watcher、Indexer、Store及Controller 5个组件展开对其进行详细阐述。希望对您有所帮助！

Informer简介

Kubernetes Informer 是 Kubernetes 客户端库中的一个核心组件，用于监控 Kubernetes API 资源的变化并在资源发生变化时通知用户。Informer 机制大大简化了 Kubernetes 中的资源管理和状态同步。以下是对 Kubernetes Informer 机制的详细解释。

Informer 机制概述

Informer 通过与 Kubernetes API 服务器交互，使用 List 和 Watch 操作来跟踪资源的状态变化。Informer 主要由以下几个部分组成：

  1. Lister：用于列出资源。
  2. Watcher：用于监控资源的变化。
  3. Indexer：用于存储和快速检索资源。
  4. Store：存储资源对象的内存缓存。
  5. Controller：用于调度和执行业务逻辑。

Informer 工作流程

  1. 初始化：Informer 初始化时，会启动一个 List 操作，从 API 服务器获取资源的初始状态，并将这些资源对象存储到本地缓存（Store）中。
  2. Watch 操作：Informer 随后启动一个 Watch 操作，用于监控资源的变化（如创建、更新、删除）。当资源发生变化时，API 服务器会将变化事件发送给 Informer。
  3. 事件处理：Informer 接收到事件后，会根据事件类型（如添加、更新、删除）对本地缓存进行更新，并调用注册的事件处理函数来处理这些变化。
  4. 同步处理：Informer 通过定期执行 List 操作来确保本地缓存的状态与 API 服务器保持一致，以防止丢失事件或网络中断导致的不同步问题。

Informer 详细组成部分

1. Lister

Lister 提供只读的资源列表操作，通常用于从本地缓存中快速获取资源。Lister 的主要接口方法包括：

  • List(selector labels.Selector) ([]*v1.Pod, error)：返回符合选择器条件的资源列表。
  • Get(name string) (*v1.Pod, error)：根据资源名称返回资源对象。
2. Watcher

Watcher 使用 Kubernetes API 的 Watch 操作来监控资源的变化。当资源发生变化时，Watcher 会接收事件并传递给 Informer。

3. Indexer

Indexer 是一个内存存储，用于存储资源对象并提供索引机制，以便快速检索资源。Indexer 提供以下功能：

  • 存储资源对象。
  • 按照索引键进行资源对象的存储和检索。
4. Store

Store 是一个简单的内存缓存，用于存储资源对象。它通常与 Indexer 结合使用，提供资源对象的快速存取。

5. Controller

Controller 负责调度和执行业务逻辑。它通过注册事件处理函数来响应资源的变化，并执行相应的操作。Controller 通常与 Informer 一起使用，以实现资源状态的自动化管理。

Informer 示例

以下是一个简单的 Go 语言示例，展示如何使用 Informer 监控 Pod 资源的变化：

代码语言：javascript
复制
package main

import (
    "fmt"
    "k8s.io/client-go/informers"
    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/clientcmd"
    "k8s.io/client-go/util/homedir"
    "path/filepath"
    "time"
)

func main() {
    kubeconfig := filepath.Join(homedir.HomeDir(), ".kube", "config")
    config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
    if err != nil {
        panic(err.Error())
    }

    clientset, err := kubernetes.NewForConfig(config)
    if err != nil {
        panic(err.Error())
    }

    factory := informers.NewSharedInformerFactory(clientset, time.Minute)
    podInformer := factory.Core().V1().Pods().Informer()

    stopCh := make(chan struct{})
    defer close(stopCh)

    podInformer.AddEventHandler(
        cache.ResourceEventHandlerFuncs{
            AddFunc: func(obj interface{}) {
                pod := obj.(*v1.Pod)
                fmt.Printf("Pod added: %s/%s\n", pod.Namespace, pod.Name)
            },
            UpdateFunc: func(oldObj, newObj interface{}) {
                oldPod := oldObj.(*v1.Pod)
                newPod := newObj.(*v1.Pod)
                fmt.Printf("Pod updated: %s/%s\n", oldPod.Namespace, oldPod.Name)
                fmt.Printf("New Pod details: %s/%s\n", newPod.Namespace, newPod.Name)
            },
            DeleteFunc: func(obj interface{}) {
                pod := obj.(*v1.Pod)
                fmt.Printf("Pod deleted: %s/%s\n", pod.Namespace, pod.Name)
            },
        },
    )

    podInformer.Run(stopCh)
}

总结

Kubernetes Informer 机制通过 List 和 Watch 操作，实现了对 Kubernetes 资源的高效监控和处理。它通过本地缓存和事件处理机制，确保资源状态的实时同步，极大地简化了 Kubernetes 集群中资源管理的复杂性。通过合理使用 Informer，可以实现对 Kubernetes 资源的精细化管理和自动化运维。

使用 Mermaid 图表工具可以直观地表示 Kubernetes Informer 的工作流程。以下是基于前述解释的 Kubernetes Informer 工作流程的 Mermaid 图表示例。

节点解释

  • Initialize Informer: 初始化 Informer。
  • List Resources from API Server: 从 API 服务器列出资源。
  • Populate Local Cache: 将资源对象存储到本地缓存。
  • Start Watch: 开始监控资源变化。
  • API Server Sends Events: API 服务器发送事件。
  • Receive Event: 接收事件。
  • Event Type: 判断事件类型（添加、更新、删除）。
  • Add Event: 处理添加事件。
  • Update Local Cache: 更新本地缓存。
  • Update Event]: 处理更新事件。
  • Delete Event: 处理删除事件。
  • Remove from Local Cache: 从本地缓存中移除资源对象。
  • Invoke Event Handlers: 调用注册的事件处理函数。
  • Process Event: 处理事件。
  • Reconcile Resource State: 协调资源状态。
  • Periodic Resync: 定期重新同步。

这张图描述了 Kubernetes Informer 的完整工作流程，包括初始化、列表操作、监视、事件接收与处理、缓存更新以及周期性重新同步等步骤。通过这些步骤，Informer 能够有效地保持本地缓存与 Kubernetes API 服务器的资源状态同步，并在资源发生变化时及时执行相应的操作。

Informer中的Lister

在 Kubernetes 的 Informer 架构中，Lister 是一个重要的组件，用于在本地缓存中存储和索引 Kubernetes API Server 中的资源对象。它提供了一种高效访问和检索资源对象的方式，避免了频繁地与 API Server 进行交互，从而提升了性能和效率。

Informer 中 Lister 的作用和功能：

  1. 资源对象的本地缓存：
    • Lister 通过在本地缓存中维护资源对象的索引，可以快速地访问和检索这些对象。这些对象通常是 Kubernetes API Server 中的一部分资源，例如 Pod、Service、Deployment 等。
  2. 索引和快速查找：
    • Lister 将资源对象按照特定的索引结构存储在本地，使得可以通过多种键（例如名称、命名空间等）快速地查找和访问资源对象。这种索引结构通常是基于内存的数据结构，如 map 或者索引库。
  3. 与 Reflector 的交互：
    • Reflector 是从 Kubernetes API Server 获取资源对象并同步到本地缓存中的组件。Lister 通过与 Reflector 协作，实现定期更新和同步资源对象的功能，确保本地缓存中的数据与 API Server 中的实际数据保持一致性。
  4. 用于事件处理和调谐（Reconciliation）：
    • 在 Informer 中，当接收到资源对象的变化事件时，Lister 负责根据本地缓存中的最新数据执行相应的操作。例如，在处理 Add、Update 和 Delete 事件时，Lister 可以直接从本地缓存中获取需要的资源对象，并将其传递给事件处理函数进行后续的调谐操作。

Listers 的优势和用途：

  • 减少 API Server 的负载：使用 Lister 可以减少对 Kubernetes API Server 的频繁访问，因为大部分的资源操作可以通过本地缓存快速完成，减轻 API Server 的负载压力。
  • 提升程序性能：Lister 通过在内存中维护资源对象的索引，提升了程序的访问速度和响应效率，特别是在需要频繁访问资源对象的场景下，比直接从 API Server 获取数据要快速和高效。
  • 支持自定义查询和过滤：在实际应用中，Lister 可以支持根据不同的查询条件和过滤器来定制和优化资源对象的检索过程，使得程序可以灵活地操作和管理 Kubernetes 中的资源。

使用 Listers 的示例：

在使用 client-go 库时，Lister 是 Informer 的一个基础组件，通常通过 SharedIndexInformer 或者其他具体的 Informer 实现来使用。以下是一个简单的示例，展示了如何使用 Listers 来获取和处理 Pod 资源对象：

代码语言：javascript
复制
package main

import (
    "flag"
    "fmt"
    "log"
    "time"

    "k8s.io/apimachinery/pkg/util/runtime"
    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/cache"
    "k8s.io/client-go/tools/clientcmd"
    "k8s.io/client-go/util/homedir"
    "path/filepath"

    corev1 "k8s.io/api/core/v1"
    "k8s.io/client-go/informers"
)

func main() {
    var kubeconfig string
    if home := homedir.HomeDir(); home != "" {
        flag.StringVar(&kubeconfig, "kubeconfig", filepath.Join(home, ".kube", "config"), "(optional) absolute path to the kubeconfig file")
    } else {
        flag.StringVar(&kubeconfig, "kubeconfig", "", "absolute path to the kubeconfig file")
    }
    flag.Parse()

    config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
    if err != nil {
        log.Fatalf("Error building kubeconfig: %v", err)
    }

    clientset, err := kubernetes.NewForConfig(config)
    if err != nil {
        log.Fatalf("Error building kubernetes clientset: %v", err)
    }

    // 创建一个 SharedIndexInformer 来监视 Pod 资源
    sharedInformerFactory := informers.NewSharedInformerFactory(clientset, time.Second*30)
    podInformer := sharedInformerFactory.Core().V1().Pods().Informer()

    // 启动 Informer，开始监视 Pod 资源
    go podInformer.Run(make(chan struct{}))

    // 等待 Informer 启动和同步完成
    if !cache.WaitForCacheSync(make(chan struct{}), podInformer.HasSynced) {
        log.Fatalf("Error syncing cache")
    }

    log.Printf("Pod Informer synced and ready")

    // 获取 Lister
    podLister := sharedInformerFactory.Core().V1().Pods().Lister()

    // 示例：通过 Lister 获取所有命名空间下的 Pod 列表
    allPods, err := podLister.List(v1.ListOptions{})
    if err != nil {
        log.Fatalf("Error listing pods: %v", err)
    }

    // 打印所有 Pod 的名称和命名空间
    for _, pod := range allPods {
        fmt.Printf("Pod: %s, Namespace: %s\n", pod.Name, pod.Namespace)
    }

    // 保持程序运行，等待事件处理
    runtime.NewControllerStopChannel().Run()
}

代码说明：

  1. 导入所需的库：
    • 引入了 Kubernetes 客户端库和 Informers 相关的库。
  2. 初始化客户端配置和客户端集合：
    • 使用 clientcmd.BuildConfigFromFlags 方法加载 kubeconfig 文件，并构建 Kubernetes 客户端配置。
    • 使用 kubernetes.NewForConfig 方法根据配置创建 Kubernetes 客户端集合。
  3. 创建 SharedIndexInformer 和 Pod Informer：
    • 使用 informers.NewSharedInformerFactory 方法创建一个 SharedIndexInformerFactory，并设置为每 30 秒同步一次。
    • 使用 sharedInformerFactory.Core().V1().Pods().Informer() 创建 Pod 的 Informer。
  4. 启动和运行 Informer：
    • 使用 podInformer.Run 方法启动 Pod Informer，并通过 cache.WaitForCacheSync 方法等待 Informer 同步完成。
  5. 获取和使用 Lister：
    • 使用 sharedInformerFactory.Core().V1().Pods().Lister() 获取 Pod 的 Lister。
    • 使用 podLister.List 方法获取所有命名空间下的 Pod 列表，并打印其名称和命名空间信息。
  6. 事件处理和停止：
    • 使用 runtime.NewControllerStopChannel().Run() 保持程序运行，等待事件处理。

这段代码演示了如何使用 Listers 在 Kubernetes 中获取和处理资源对象（如 Pod），并利用其快速访问和索引的优势。Lister 在 Informer 架构中扮演了重要角色，帮助提升程序的性能和效率，特别是在需要频繁访问和管理资源对象的场景下。

Informer中的Watcher

在 Kubernetes 的 Informer 架构中，Watcher 是一种用于监视和接收资源对象变化事件的重要组件。Watcher 负责与 Kubernetes API Server 建立连接，并订阅特定资源对象的变化通知。当 API Server 上的资源对象发生变化（如创建、更新、删除等操作）时，Watcher 将接收到相应的事件通知，并将这些事件传递给相应的 Informer 进行处理。

Watcher 的作用和功能：

  1. 实时监视资源对象的变化：
    • Watcher 建立长连接与 Kubernetes API Server 进行通信，实时监视特定资源对象（如 Pod、Deployment 等）的变化。
    • 当 API Server 上的资源对象发生变化时，Watcher 会立即接收到相应的事件通知，并将事件推送给注册了相应资源类型的 Informer。
  2. 事件的分类和传递：
    • Watcher 监视的事件主要包括 Add、Update 和 Delete 等操作。这些事件表示资源对象的创建、更新和删除操作。
    • Watcher 会将这些事件封装成事件对象（Event）并传递给 Informer，从而触发 Informer 中注册的事件处理函数（Event Handlers）执行相应的业务逻辑。
  3. 与 Reflector 的协作：
    • Reflector 是 Informer 架构中负责从 API Server 同步资源对象到本地缓存的组件。
    • Watcher 与 Reflector 协作，当 Reflector 从 API Server 获取到新的资源对象时，Watcher 将会监测这些对象，并根据需要将变化事件通知给相应的 Informer。
  4. 支持多种资源对象的监视：
    • Watcher 可以同时监视多种不同类型的资源对象。例如，可以创建多个 Watcher 分别监视 Pod、Service 等资源对象的变化，从而实现对多种资源类型的实时监控和处理。

Watcher 的优势和用途：

  • 实时性和响应性：Watcher 提供了对 Kubernetes 资源对象变化的实时监视和响应能力，确保系统能够及时捕获和处理重要的资源操作。
  • 减少轮询和提升效率：与传统的轮询方式相比，Watcher 的长连接机制能够减少不必要的网络负载和延迟，提升了系统的性能和效率。
  • 与 Informer 结合使用：Watcher 与 Informer 结合使用，使得应用程序可以通过注册事件处理函数来响应和处理资源对象的变化，实现了业务逻辑的解耦和管理。

示例：

在 client-go 中，Watcher 通常由 SharedIndexInformer 或者 Factory 创建和管理。以下是一个简单示例，展示如何使用 Watcher 监视 Pod 资源对象的变化：

代码语言：javascript
复制
package main

import (
    "flag"
    "fmt"
    "log"
    "time"

    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/clientcmd"
    "k8s.io/client-go/util/homedir"
    "path/filepath"

    "k8s.io/apimachinery/pkg/util/runtime"
    "k8s.io/client-go/tools/cache"
    "k8s.io/client-go/informers"
    corev1 "k8s.io/api/core/v1"
)

func main() {
    var kubeconfig string
    if home := homedir.HomeDir(); home != "" {
        flag.StringVar(&kubeconfig, "kubeconfig", filepath.Join(home, ".kube", "config"), "(optional) absolute path to the kubeconfig file")
    } else {
        flag.StringVar(&kubeconfig, "kubeconfig", "", "absolute path to the kubeconfig file")
    }
    flag.Parse()

    config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
    if err != nil {
        log.Fatalf("Error building kubeconfig: %v", err)
    }

    clientset, err := kubernetes.NewForConfig(config)
    if err != nil {
        log.Fatalf("Error building kubernetes clientset: %v", err)
    }

    // 创建一个 SharedIndexInformer 来监视 Pod 资源
    sharedInformerFactory := informers.NewSharedInformerFactory(clientset, time.Second*30)
    podInformer := sharedInformerFactory.Core().V1().Pods().Informer()

    // 定义 Watcher 事件处理函数
    podInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{
        AddFunc: func(obj interface{}) {
            pod := obj.(*corev1.Pod)
            fmt.Printf("Pod added: %s/%s\n", pod.Namespace, pod.Name)
        },
        UpdateFunc: func(oldObj, newObj interface{}) {
            newPod := newObj.(*corev1.Pod)
            oldPod := oldObj.(*corev1.Pod)
            fmt.Printf("Pod updated: %s/%s\n", newPod.Namespace, newPod.Name)
        },
        DeleteFunc: func(obj interface{}) {
            pod := obj.(*corev1.Pod)
            fmt.Printf("Pod deleted: %s/%s\n", pod.Namespace, pod.Name)
        },
    })

    // 启动 Informer，开始监视 Pod 资源
    go podInformer.Run(make(chan struct{}))

    // 等待 Informer 启动和同步完成
    if !cache.WaitForCacheSync(make(chan struct{}), podInformer.HasSynced) {
        log.Fatalf("Error syncing cache")
    }

    log.Printf("Pod Informer synced and ready")

    // 保持程序运行，等待事件处理
    runtime.NewControllerStopChannel().Run()
}

代码说明：

  • 代码中使用 podInformer.Run 启动了 Pod 的 Informer，并通过 cache.WaitForCacheSync 等待 Informer 同步完成。
  • Watcher 通过 Informer 从 Kubernetes API Server 获取 Pod 资源对象的变化事件，并通过定义的事件处理函数处理这些事件，从而实现对 Pod 资源变化的监视和响应。

这段示例代码展示了 Watcher 在 Informer 架构中的典型应用，用于实时监视和处理 Kubernetes 资源对象的变化事件，保证应用程序能够实时响应并处理重要的资源操作。

Informer中的Indexer

在 Kubernetes 的 Informer 架构中，Indexer 是一个关键的组件，用于在本地缓存中维护和管理资源对象的索引。Indexer 的主要作用是提供高效的资源对象检索和访问能力，通过多种索引方式（如名称、命名空间等）组织和存储资源对象，以支持快速的数据查询和操作。

Indexer 的作用和功能：

  1. 资源对象的索引和存储：
    • Indexer 在本地缓存中维护资源对象的索引结构，可以根据多种键（如名称、命名空间、标签等）快速定位和检索资源对象。
    • Kubernetes 中的资源对象（如 Pod、Service、Deployment 等）通常以键值对的形式存储在 Indexer 中，以支持快速的数据访问和操作。
  2. 支持多种索引方式：
    • Indexer 支持多种索引策略，可以根据需求创建和管理不同类型的索引。例如，可以根据资源对象的名称建立索引，也可以根据资源对象的命名空间或标签建立索引。
    • 这些索引可以根据具体的业务需求进行灵活配置和管理，以提升数据的查询效率和性能。
  3. 与 Reflector 和 Watcher 的协作：
    • Reflector 负责从 Kubernetes API Server 获取资源对象的最新状态，并同步到 Indexer 维护的本地缓存中。
    • Watcher 监视 API Server 上资源对象的变化，并根据变化事件更新 Indexer 中相应的索引和数据条目，保持本地缓存与 API Server 数据的一致性。
  4. 用于 Informer 的事件处理：
    • 在 Informer 架构中，当发生资源对象的增删改事件时，Indexer 可以快速检索到受影响的资源对象，并更新相关的索引数据。
    • 这些索引数据可以帮助 Informer 快速定位和处理事件，执行相应的业务逻辑，如触发事件处理函数或者更新 UI 界面。

Indexer 的优势和用途：

  • 提升数据访问效率：Indexer 通过在本地缓存中维护索引结构，避免了频繁访问 Kubernetes API Server，从而大大提升了资源对象的检索和访问效率。
  • 支持自定义查询和过滤：Indexer 支持基于多种索引键的数据查询和过滤，可以根据业务需求灵活配置和优化索引策略，以满足不同场景下的数据访问需求。
  • 与 Informer 和控制器的紧密集成：Indexer 是 Informer 架构中的核心组件之一，与 Reflector、Watcher 和事件处理函数紧密集成，共同实现对 Kubernetes 资源对象的监视、管理和操作。

示例：

以下是一个简化的示例，展示如何使用 client-go 库中的 Indexer 对 Pod 资源对象进行索引和查询：

代码语言：javascript
复制
package main

import (
    "flag"
    "fmt"
    "log"
    "time"

    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/clientcmd"
    "k8s.io/client-go/util/homedir"
    "path/filepath"

    "k8s.io/apimachinery/pkg/util/runtime"
    "k8s.io/client-go/tools/cache"
    "k8s.io/client-go/informers"
    corev1 "k8s.io/api/core/v1"
)

func main() {
    var kubeconfig string
    if home := homedir.HomeDir(); home != "" {
        flag.StringVar(&kubeconfig, "kubeconfig", filepath.Join(home, ".kube", "config"), "(optional) absolute path to the kubeconfig file")
    } else {
        flag.StringVar(&kubeconfig, "kubeconfig", "", "absolute path to the kubeconfig file")
    }
    flag.Parse()

    config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
    if err != nil {
        log.Fatalf("Error building kubeconfig: %v", err)
    }

    clientset, err := kubernetes.NewForConfig(config)
    if err != nil {
        log.Fatalf("Error building kubernetes clientset: %v", err)
    }

    // 创建一个 SharedIndexInformer 来监视 Pod 资源
    sharedInformerFactory := informers.NewSharedInformerFactory(clientset, time.Second*30)
    podInformer := sharedInformerFactory.Core().V1().Pods().Informer()

    // 创建一个 Indexer
    indexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{})

    // 定义 Watcher 事件处理函数，并将事件添加到 Indexer 中
    podInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{
        AddFunc: func(obj interface{}) {
            pod := obj.(*corev1.Pod)
            fmt.Printf("Pod added: %s/%s\n", pod.Namespace, pod.Name)
            indexer.Add(pod)
        },
        UpdateFunc: func(oldObj, newObj interface{}) {
            newPod := newObj.(*corev1.Pod)
            oldPod := oldObj.(*corev1.Pod)
            fmt.Printf("Pod updated: %s/%s\n", newPod.Namespace, newPod.Name)
            indexer.Update(newPod)
        },
        DeleteFunc: func(obj interface{}) {
            pod := obj.(*corev1.Pod)
            fmt.Printf("Pod deleted: %s/%s\n", pod.Namespace, pod.Name)
            indexer.Delete(pod)
        },
    })

    // 启动 Informer，开始监视 Pod 资源
    go podInformer.Run(make(chan struct{}))

    // 等待 Informer 启动和同步完成
    if !cache.WaitForCacheSync(make(chan struct{}), podInformer.HasSynced) {
        log.Fatalf("Error syncing cache")
    }

    log.Printf("Pod Informer synced and ready")

    // 示例：通过 Indexer 查询所有命名空间下的 Pod 列表
    allPods, err := indexer.ByIndex(cache.NamespaceIndex, "")
    if err != nil {
        log.Fatalf("Error listing pods: %v", err)
    }

    // 打印所有 Pod 的名称和命名空间
    for _, obj := range allPods {
        pod := obj.(*corev1.Pod)
        fmt.Printf("Pod: %s, Namespace: %s\n", pod.Name, pod.Namespace)
    }

    // 保持程序运行，等待事件处理
    runtime.NewControllerStopChannel().Run()
}

代码说明：

  • 代码中使用 cache.NewIndexer 创建了一个简单的 Indexer，并将其与 Pod 的 Informer 绑定。
  • Indexer 通过 AddFunc、UpdateFunc 和 DeleteFunc 方法处理 Pod 资源对象的增删改事件，并更新 Indexer 中的索引数据。
  • 示例代码中，通过 indexer.ByIndex 方法查询所有命名空间下的 Pod 列表，并打印其名称和命名空间信息。

这段示例代码展示了 Indexer 在 Informer 架构中的典型应用，通过维护资源对象的索引结构，实现了对 Kubernetes 资源对象的高效查询和访问，为应用程序提供了快速的数据检索和操作能力。

Informer中的Store

在 Kubernetes 的 Informer 架构中，Store 是一个重要的组件，用于在本地缓存中存储和管理 Kubernetes 资源对象的数据。Store 主要负责管理缓存中的资源对象集合，并提供对这些对象的快速访问、查询和操作能力，以支持 Informer 和其他控制器对资源对象的监视、管理和事件处理。

Store 的作用和功能：

  1. 资源对象的存储和索引：
    • Store 在内存中维护资源对象的集合，通常使用 Map 结构来存储。每个资源对象都会根据其唯一的键（例如名称和命名空间）作为索引，存储在 Store 中。
    • Store 提供了高效的插入、更新、删除和检索操作，以支持对资源对象集合的管理和维护。
  2. 支持多种查询和过滤：
    • Store 支持根据资源对象的不同属性和索引键进行快速的数据查询和过滤。例如，可以根据名称、命名空间、标签等条件查询资源对象，并返回符合条件的对象列表。
  3. 与 Reflector 和 Watcher 的协作：
    • Reflector 负责从 Kubernetes API Server 获取最新的资源对象状态，并同步到 Store 中，保持本地缓存与 API Server 数据的一致性。
    • Watcher 监视 API Server 上资源对象的变化，并根据事件通知更新 Store 中相应的资源对象数据，以确保缓存中的数据能够及时反映出最新的资源状态。
  4. 用于 Informer 的事件处理：
    • 在 Informer 架构中，Store 是 Informer 的基础组件之一。当 Watcher 接收到资源对象的增删改事件时，会将这些事件更新到 Store 中。
    • Informer 可以通过监听 Store 的变化事件，实时捕获和处理资源对象的变化，触发注册的事件处理函数执行相应的业务逻辑。

Store 的优势和用途：

  • 提升数据访问效率：Store 提供了高效的数据访问接口，避免了频繁访问 Kubernetes API Server，从而提升了资源对象的检索和操作效率。
  • 支持事件驱动的编程模型：Store 与 Watcher 结合使用，支持事件驱动的编程模型，使得应用程序能够实时响应和处理 Kubernetes 资源对象的变化事件。
  • 灵活的数据管理和操作能力：Store 支持多种索引策略和查询方式，可以根据业务需求灵活配置和管理数据存储，为应用程序提供了丰富的数据管理和操作能力。

示例：

以下是一个简化的示例，展示如何使用 client-go 库中的 Store 对 Pod 资源对象进行存储和查询：

代码语言：javascript
复制
package main

import (
    "flag"
    "fmt"
    "log"
    "time"

    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/clientcmd"
    "k8s.io/client-go/util/homedir"
    "path/filepath"

    "k8s.io/apimachinery/pkg/util/runtime"
    "k8s.io/client-go/tools/cache"
    "k8s.io/client-go/informers"
    corev1 "k8s.io/api/core/v1"
)

func main() {
    var kubeconfig string
    if home := homedir.HomeDir(); home != "" {
        flag.StringVar(&kubeconfig, "kubeconfig", filepath.Join(home, ".kube", "config"), "(optional) absolute path to the kubeconfig file")
    } else {
        flag.StringVar(&kubeconfig, "kubeconfig", "", "absolute path to the kubeconfig file")
    }
    flag.Parse()

    config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
    if err != nil {
        log.Fatalf("Error building kubeconfig: %v", err)
    }

    clientset, err := kubernetes.NewForConfig(config)
    if err != nil {
        log.Fatalf("Error building kubernetes clientset: %v", err)
    }

    // 创建一个 SharedIndexInformer 来监视 Pod 资源
    sharedInformerFactory := informers.NewSharedInformerFactory(clientset, time.Second*30)
    podInformer := sharedInformerFactory.Core().V1().Pods().Informer()

    // 创建一个 Store
    store := cache.NewStore(cache.MetaNamespaceKeyFunc)

    // 定义 Watcher 事件处理函数，并将事件添加到 Store 中
    podInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{
        AddFunc: func(obj interface{}) {
            pod := obj.(*corev1.Pod)
            fmt.Printf("Pod added: %s/%s\n", pod.Namespace, pod.Name)
            store.Add(pod)
        },
        UpdateFunc: func(oldObj, newObj interface{}) {
            newPod := newObj.(*corev1.Pod)
            oldPod := oldObj.(*corev1.Pod)
            fmt.Printf("Pod updated: %s/%s\n", newPod.Namespace, newPod.Name)
            store.Update(newPod)
        },
        DeleteFunc: func(obj interface{}) {
            pod := obj.(*corev1.Pod)
            fmt.Printf("Pod deleted: %s/%s\n", pod.Namespace, pod.Name)
            store.Delete(pod)
        },
    })

    // 启动 Informer，开始监视 Pod 资源
    go podInformer.Run(make(chan struct{}))

    // 等待 Informer 启动和同步完成
    if !cache.WaitForCacheSync(make(chan struct{}), podInformer.HasSynced) {
        log.Fatalf("Error syncing cache")
    }

    log.Printf("Pod Informer synced and ready")

    // 示例：通过 Store 查询所有命名空间下的 Pod 列表
    allPods := store.List()

    // 打印所有 Pod 的名称和命名空间
    for _, obj := range allPods {
        pod := obj.(*corev1.Pod)
        fmt.Printf("Pod: %s, Namespace: %s\n", pod.Name, pod.Namespace)
    }

    // 保持程序运行，等待事件处理
    runtime.NewControllerStopChannel().Run()
}

代码说明：

  • 代码中使用 cache.NewStore 创建了一个简单的 Store，并将其与 Pod 的 Informer 绑定。
  • Store 通过 AddFunc、UpdateFunc 和 DeleteFunc 方法处理 Pod 资源对象的增删改事件，并更新 Store 中的数据。
  • 示例代码中，通过 store.List 方法查询所有存储在 Store 中的 Pod 资源对象，并打印其名称和命名空间信息。

这段示例代码展示了 Store 在 Informer 架构中的典型应用，通过管理和维护资源对象的本地缓存，实现了对 Kubernetes 资源对象的高效存储、查询和访问，为应用程序提供了快速和可靠的数据管理能力。

Informer中的Controller

在 Kubernetes 中，Informer 架构中的 Controller 是负责监视和控制资源对象的逻辑组件，它通过监听 Informer 中的事件，并根据事件触发相应的业务逻辑或操作，来实现对资源对象的管理和控制。Controller 在 Kubernetes 中扮演着非常重要的角色，可以根据具体的需求实现各种自定义的控制逻辑，例如自动伸缩、负载均衡、故障恢复等。

Controller 的作用和功能：

  1. 事件监听和处理：
    • Controller 通过 Watcher 监听 Kubernetes API Server 上资源对象的变化事件，包括增加、更新和删除操作。
    • 当 Watcher 接收到事件通知时，Controller 根据事件类型调用相应的处理函数（如 Add、Update、Delete 函数），执行预定义的业务逻辑或操作。
  2. 资源对象的管理和控制：
    • Controller 可以实现对资源对象的自动化管理和控制，例如根据 CPU 使用率动态调整 Pod 的副本数，或者根据负载情况自动调整 Service 的端口映射。
    • 通过与 Informer 结合使用，Controller 可以实现对资源对象状态的实时监控和反馈，确保系统在各种场景下的稳定和可靠运行。
  3. 与业务逻辑的集成：
    • Controller 可以根据具体的业务需求定制化，实现各种复杂的控制逻辑。例如，基于应用程序的性能指标自动调整资源分配，或者基于用户配置的策略实现故障转移和容错处理。
  4. 实现自定义控制器：
    • Kubernetes 允许用户根据自身业务需求开发和部署自定义的 Controller。用户可以使用 client-go 库中提供的工具和接口，快速实现和部署自定义控制器，以适应不同的业务场景和需求。

示例场景：

以下是一个简化的示例场景，展示了如何使用 Informer 和 Controller 实现对 Deployment 资源对象的自动伸缩控制：

代码语言：javascript
复制
package main

import (
    "flag"
    "fmt"
    "log"
    "time"

    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/clientcmd"
    "k8s.io/client-go/util/homedir"
    "path/filepath"

    "k8s.io/apimachinery/pkg/util/runtime"
    "k8s.io/client-go/tools/cache"
    "k8s.io/client-go/informers"
    appsv1 "k8s.io/api/apps/v1"
)

func main() {
    var kubeconfig string
    if home := homedir.HomeDir(); home != "" {
        flag.StringVar(&kubeconfig, "kubeconfig", filepath.Join(home, ".kube", "config"), "(optional) absolute path to the kubeconfig file")
    } else {
        flag.StringVar(&kubeconfig, "kubeconfig", "", "absolute path to the kubeconfig file")
    }
    flag.Parse()

    config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
    if err != nil {
        log.Fatalf("Error building kubeconfig: %v", err)
    }

    clientset, err := kubernetes.NewForConfig(config)
    if err != nil {
        log.Fatalf("Error building kubernetes clientset: %v", err)
    }

    // 创建一个 SharedIndexInformer 来监视 Deployment 资源
    sharedInformerFactory := informers.NewSharedInformerFactory(clientset, time.Second*30)
    deploymentInformer := sharedInformerFactory.Apps().V1().Deployments().Informer()

    // 定义 Controller 控制逻辑
    controller := NewDeploymentController(clientset, deploymentInformer)

    // 启动 Informer，开始监视 Deployment 资源
    go deploymentInformer.Run(make(chan struct{}))

    // 等待 Informer 启动和同步完成
    if !cache.WaitForCacheSync(make(chan struct{}), deploymentInformer.HasSynced) {
        log.Fatalf("Error syncing cache")
    }

    log.Printf("Deployment Informer synced and ready")

    // 保持程序运行，等待事件处理
    runtime.NewControllerStopChannel().Run()
}

// DeploymentController 定义一个简单的 Deployment 控制器
type DeploymentController struct {
    clientset  *kubernetes.Clientset
    informer   cache.SharedIndexInformer
}

// NewDeploymentController 创建一个新的 DeploymentController
func NewDeploymentController(clientset *kubernetes.Clientset, informer cache.SharedIndexInformer) *DeploymentController {
    controller := &DeploymentController{
        clientset:  clientset,
        informer:   informer,
    }

    // 注册事件处理函数
    informer.AddEventHandler(cache.ResourceEventHandlerFuncs{
        AddFunc:    controller.handleDeploymentAdd,
        UpdateFunc: controller.handleDeploymentUpdate,
        DeleteFunc: controller.handleDeploymentDelete,
    })

    return controller
}

// 处理 Deployment 资源的添加事件
func (c *DeploymentController) handleDeploymentAdd(obj interface{}) {
    deployment := obj.(*appsv1.Deployment)
    fmt.Printf("Deployment added: %s/%s\n", deployment.Namespace, deployment.Name)

    // 在这里编写自定义的添加处理逻辑，例如自动扩展 Pod 副本数
}

// 处理 Deployment 资源的更新事件
func (c *DeploymentController) handleDeploymentUpdate(oldObj, newObj interface{}) {
    newDeployment := newObj.(*appsv1.Deployment)
    oldDeployment := oldObj.(*appsv1.Deployment)
    fmt.Printf("Deployment updated: %s/%s\n", newDeployment.Namespace, newDeployment.Name)

    // 在这里编写自定义的更新处理逻辑
}

// 处理 Deployment 资源的删除事件
func (c *DeploymentController) handleDeploymentDelete(obj interface{}) {
    deployment := obj.(*appsv1.Deployment)
    fmt.Printf("Deployment deleted: %s/%s\n", deployment.Namespace, deployment.Name)

    // 在这里编写自定义的删除处理逻辑
}

代码说明：

  • 示例代码中创建了一个 DeploymentController 结构体，并在 NewDeploymentController 函数中初始化并注册了 Informer 的事件处理函数。
  • handleDeploymentAdd、handleDeploymentUpdate 和 handleDeploymentDelete 方法分别处理 Deployment 资源的增加、更新和删除事件，每个方法中都可以编写自定义的业务逻辑。
  • Controller 可以根据具体的业务需求实现各种自动化控制逻辑，例如根据资源使用率自动调整 Pod 的副本数，或者根据策略更新 Deployment 的配置信息。

这段示例代码展示了 Controller 在 Kubernetes 中的典型应用，通过与 Informer 结合使用，实现了对 Deployment 资源对象的监视、管理和控制，为应用程序提供了灵活和强大的自动化操作能力。

Informer会丢失事件吗

在 Kubernetes 的 Informer 机制中，理论上 Informer 通过与 API Server 的长连接（watch）和定期的全量同步（resync）来确保事件不会丢失。但在某些情况下，Informer 仍然可能会丢失事件或出现延迟。这些情况主要包括以下几种：

事件丢失的潜在原因：

  1. 连接中断：
    • Informer 与 API Server 之间的 watch 长连接可能会由于网络问题、API Server 重启等原因而中断。
    • 当连接中断时，Informer 可能会丢失在此期间发生的事件。
  2. 事件缓冲区溢出：
    • Kubernetes API Server 会维护一个事件缓冲区，用于存储事件。如果事件产生的速度超过了消费速度，缓冲区可能会溢出，从而导致部分事件被丢弃。
  3. API Server 负载过高：
    • 在高负载的集群环境中，API Server 的性能可能会下降，从而导致事件的处理和传输出现延迟，甚至丢失。

防止事件丢失的机制：

  1. 重新连接和重新同步：
    • 当 watch 连接中断时，Informer 会自动重新建立连接，并从断开点继续获取事件。
    • Informer 还会定期进行全量同步（resync），确保即使在丢失部分事件的情况下，也能通过全量同步恢复一致性。
  2. 基于资源版本的事件处理：
    • Informer 会维护资源对象的资源版本（resourceVersion），以确保在重新连接和重新同步时，能够从正确的版本开始获取事件。
    • 资源版本机制可以有效减少重复事件的处理和丢失事件的风险。
  3. 事件处理的幂等性：
    • Informer 的事件处理函数通常是幂等的，即同一个事件多次处理的结果是相同的。这样即使由于网络或其他原因导致事件重复处理，也不会影响系统的正确性。

实践中的注意事项：

  1. 设置合理的 resync 间隔：
    • 根据具体的应用需求和系统负载，设置合适的 resync 间隔时间，可以在一定程度上降低事件丢失的风险。
  2. 监控和日志记录：
    • 通过监控和日志记录，可以及时发现和诊断事件丢失的问题。例如，监控 Informer 的连接状态、事件处理延迟等指标，可以帮助快速定位和解决问题。
  3. 使用 SharedInformerFactory：
    • 使用 SharedInformerFactory 可以在多个控制器之间共享同一个 Informer，提高资源利用效率，减少对 API Server 的负载。

代码示例：

以下是一个示例，展示了如何处理 Informer 的事件丢失和重新同步：

代码语言：javascript
复制
package main

import (
    "flag"
    "fmt"
    "log"
    "time"

    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/clientcmd"
    "k8s.io/client-go/util/homedir"
    "path/filepath"

    "k8s.io/apimachinery/pkg/util/runtime"
    "k8s.io/client-go/tools/cache"
    "k8s.io/client-go/informers"
    corev1 "k8s.io/api/core/v1"
)

func main() {
    var kubeconfig string
    if home := homedir.HomeDir(); home != "" {
        flag.StringVar(&kubeconfig, "kubeconfig", filepath.Join(home, ".kube", "config"), "(optional) absolute path to the kubeconfig file")
    } else {
        flag.StringVar(&kubeconfig, "kubeconfig", "", "absolute path to the kubeconfig file")
    }
    flag.Parse()

    config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
    if err != nil {
        log.Fatalf("Error building kubeconfig: %v", err)
    }

    clientset, err := kubernetes.NewForConfig(config)
    if err != nil {
        log.Fatalf("Error building kubernetes clientset: %v", err)
    }

    // 创建一个 SharedIndexInformer 来监视 Pod 资源
    sharedInformerFactory := informers.NewSharedInformerFactory(clientset, time.Second*30)
    podInformer := sharedInformerFactory.Core().V1().Pods().Informer()

    // 定义事件处理函数
    podInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{
        AddFunc: func(obj interface{}) {
            pod := obj.(*corev1.Pod)
            fmt.Printf("Pod added: %s/%s\n", pod.Namespace, pod.Name)
        },
        UpdateFunc: func(oldObj, newObj interface{}) {
            newPod := newObj.(*corev1.Pod)
            oldPod := oldObj.(*corev1.Pod)
            fmt.Printf("Pod updated: %s/%s\n", newPod.Namespace, newPod.Name)
        },
        DeleteFunc: func(obj interface{}) {
            pod := obj.(*corev1.Pod)
            fmt.Printf("Pod deleted: %s/%s\n", pod.Namespace, pod.Name)
        },
    })

    // 启动 Informer，开始监视 Pod 资源
    stopCh := make(chan struct{})
    defer close(stopCh)
    go podInformer.Run(stopCh)

    // 等待 Informer 启动和同步完成
    if !cache.WaitForCacheSync(stopCh, podInformer.HasSynced) {
        log.Fatalf("Error syncing cache")
    }

    log.Printf("Pod Informer synced and ready")

    // 保持程序运行，等待事件处理
    runtime.NewControllerStopChannel().Run()
}

代码说明：

  • 代码中创建了一个 Pod 的 SharedIndexInformer，并定义了资源事件的处理函数。
  • 使用 cache.WaitForCacheSync 方法等待 Informer 的初始同步完成，确保缓存中有最新的资源状态。
  • 当连接中断时，Informer 会自动重新建立连接，并从断开点继续获取事件。
  • 定期进行全量同步（通过 SharedInformerFactory 设置的间隔时间），确保缓存中的数据与 API Server 保持一致。

通过合理配置和使用 Kubernetes Informer，可以在大多数情况下避免事件丢失，并确保系统的稳定性和一致性。

ShareInformer和Informer

在 Kubernetes 中，Informer 和 SharedInformer 是用于监视和缓存 Kubernetes 资源对象状态变化的工具，它们在实现上有一些区别和适用场景的差异。

Informer

Informer 是 Kubernetes 客户端库（例如 client-go）提供的一种机制，用于从 Kubernetes API Server 监听特定资源对象的变化事件（如 Pod、Deployment 等）。每个 Informer 实例都独立维护着对应资源对象的本地缓存，并通过长连接（watch）从 API Server 接收事件通知。以下是 Informer 的主要特点和应用场景：

  • 特点：
    • 每个 Informer 实例独立维护资源对象的缓存，对资源对象的状态变化（增删改）实时感知。
    • 可以通过调用 Informer 提供的 List 方法，从缓存中获取最新的资源列表。
    • 提供了事件处理函数的注册接口，允许用户定义资源对象状态变化时的处理逻辑。
  • 应用场景：
    • 单一控制逻辑：适用于需要单一控制逻辑的场景，例如监控 Pod 状态变化并触发特定操作。
    • 定制化需求：可以根据具体需求定制 Informer 的事件处理函数，实现复杂的控制逻辑。

SharedInformer

SharedInformer 是对 Informer 的一种封装和扩展，它在 Kubernetes 客户端库（client-go）中提供，主要用于在多个控制器之间共享资源对象的监视和缓存。SharedInformer 可以有效地减少对 API Server 的请求次数，提高资源利用率，并简化多个控制器之间资源状态同步的复杂性。以下是 SharedInformer 的主要特点和应用场景：

  • 特点：
    • 所有使用同一个 SharedInformerFactory 创建的 SharedInformer 实例都共享同一个缓存。
    • 通过工厂方法提供了一种创建和管理 SharedInformer 的标准化方式。
    • 可以通过 SharedInformer 的事件处理函数，实现多个控制器之间资源状态的协调和同步。
  • 应用场景：
    • 多控制器协同：适用于需要多个控制器协同工作的场景，例如 Pod Controller 和 Service Controller 都需要监视和操作相同的 Pod 资源。
    • 资源复用：可以有效地复用和共享资源对象的监视和状态，减少重复操作和资源浪费。

区别与联系

  1. 区别：
    • 独立性：Informer 是独立维护资源对象的缓存和事件监听，每个实例操作的资源对象不同。
    • 共享性：SharedInformer 使用同一个缓存，多个实例共享相同的资源对象状态。
  2. 联系：
    • SharedInformer 是在 Informer 的基础上扩展和封装而成，它们都能够监视和处理 Kubernetes 资源对象的状态变化。
    • 都可以通过注册事件处理函数，实现对资源对象状态变化的响应和控制。

示例应用场景

示例场景：假设有一个监控系统需要同时监视 Pod 的状态并执行相应的操作：

  • 使用 Informer：如果每个控制逻辑都有自己的需求和操作方式，可以为每个控制器创建独立的 Pod Informer，每个 Informer 独立监听 Pod 的状态变化，并执行各自的操作逻辑。
  • 使用 SharedInformer：如果多个控制器需要协同工作，并且需要共享相同的 Pod 状态信息，可以使用 SharedInformerFactory 创建一个共享的 Pod SharedInformer 实例，多个控制器共同使用这个 SharedInformer 实例，以确保资源状态的一致性和操作的协调。

通过选择合适的 Informer 或 SharedInformer 可以根据具体的业务需求和系统架构来优化资源对象的监视和控制，提高系统的效率和可扩展性。

Informer精髓浅析

Informer 在 Kubernetes 中设计的精髓主要体现在以下几个方面：

  1. 事件驱动的架构：
    • Kubernetes 中的大部分组件和控制器都是基于事件驱动的设计。Informer 通过长连接（watch）实时监听 Kubernetes API Server 上资源对象的状态变化，如增加、更新和删除操作，从而可以即时感知集群中各个资源对象的变化。
  2. 本地缓存和同步策略：
    • Informer 维护了一个本地的缓存（Store），用于存储最近获取的资源对象状态。通过定期的全量同步（resync）机制，可以保持本地缓存与 API Server 上数据的一致性，即使在网络故障或连接中断的情况下也能够恢复数据的准确性。
  3. 资源版本控制：
    • 每个资源对象在 Kubernetes API Server 上都有一个唯一的资源版本号（resourceVersion），Informer 利用这个版本号来确保在重新连接和重新同步时，能够从正确的断点开始获取事件。这种设计保证了事件处理的一致性和可靠性。
  4. 灵活的事件处理机制：
    • Informer 提供了灵活的事件处理函数注册接口（AddFunc、UpdateFunc、DeleteFunc 等），允许开发者根据具体的业务需求定义资源对象状态变化时的处理逻辑。这种灵活性使得开发者可以根据不同的场景定制化事件处理流程，实现各种复杂的控制逻辑。
  5. 客户端库的抽象和封装：
    • Kubernetes 客户端库（如 client-go）在设计上将底层与应用逻辑进行了有效的抽象和封装，使得开发者可以专注于业务逻辑的实现，而不必过多关注与 Kubernetes API 交互的细节。Informer 作为其中一个重要的组件，为开发者提供了便捷而强大的资源监视和控制能力。
  6. 可扩展性和性能优化：
    • Informer 设计考虑了大规模集群的性能和扩展性问题。通过合理的缓存策略、事件处理优化和并发控制，可以有效地减少对 API Server 的请求次数和系统资源的消耗，从而提高整体系统的性能表现和可扩展性。

总的来说，Informer 设计的精髓在于其基于事件驱动的实时监视能力、本地缓存与同步策略的高效性、灵活的事件处理机制以及对大规模集群性能和可扩展性的考量。这些特点使得 Informer 成为 Kubernetes 中实现控制器逻辑和应用程序与集群交互的核心组件之一。

本文参与 腾讯云自媒体同步曝光计划，分享自微信公众号。
原始发表：2024-06-28，如有侵权请联系 cloudcommunity@tencent.com 删除
同步
kubernetes
缓存
对象
事件

本文分享自 锅总 微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ，欢迎热爱写作的你一起参与！

同步
kubernetes
缓存
对象
事件
评论
登录后参与评论
0 条评论
热度
最新
登录 后参与评论
推荐阅读
LV.
文章
0
获赞
0
目录
  • Informer简介
    • Informer 机制概述
      • Informer 工作流程
        • Informer 详细组成部分
          • 1. Lister
          • 2. Watcher
          • 3. Indexer
          • 4. Store
          • 5. Controller
        • Informer 示例
          • 总结
            • 节点解释
            • Informer中的Lister
              • Informer 中 Lister 的作用和功能：
                • Listers 的优势和用途：
                  • 使用 Listers 的示例：
                    • 代码说明：
                    • Informer中的Watcher
                      • Watcher 的作用和功能：
                        • Watcher 的优势和用途：
                          • 示例：
                            • 代码说明：
                            • Informer中的Indexer
                              • Indexer 的作用和功能：
                                • Indexer 的优势和用途：
                                  • 示例：
                                    • 代码说明：
                                    • Informer中的Store
                                      • Store 的作用和功能：
                                        • Store 的优势和用途：
                                          • 示例：
                                            • 代码说明：
                                            • Informer中的Controller
                                              • Controller 的作用和功能：
                                                • 示例场景：
                                                  • 代码说明：
                                                  • Informer会丢失事件吗
                                                    • 事件丢失的潜在原因：
                                                      • 防止事件丢失的机制：
                                                        • 实践中的注意事项：
                                                          • 代码示例：
                                                            • 代码说明：
                                                            • ShareInformer和Informer
                                                              • Informer
                                                                • SharedInformer
                                                                  • 区别与联系
                                                                    • 示例应用场景
                                                                    • Informer精髓浅析
                                                                    相关产品与服务
                                                                    容器服务
                                                                    腾讯云容器服务（Tencent Kubernetes Engine, TKE）基于原生 kubernetes 提供以容器为核心的、高度可扩展的高性能容器管理服务，覆盖 Serverless、边缘计算、分布式云等多种业务部署场景，业内首创单个集群兼容多种计算节点的容器资源管理模式。同时产品作为云原生 Finops 领先布道者，主导开源项目Crane，全面助力客户实现资源优化、成本控制。
                                                                    产品介绍产品文档
                                                                    领券

                                                                    腾讯云开发者

                                                                    扫码关注腾讯云开发者

                                                                    扫码关注腾讯云开发者

                                                                    领取腾讯云代金券

                                                                    热门产品

                                                                    热门推荐

                                                                    更多推荐

                                                                    Copyright © 2013 - 2024 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有 

                                                                    深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569

                                                                    腾讯云计算（北京）有限责任公司 京ICP证150476号 |  京ICP备11018762号 | 京公网安备号11010802020287

                                                                    问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档

                                                                    Copyright © 2013 - 2024 Tencent Cloud.

                                                                    All Rights Reserved. 腾讯云 版权所有

                                                                    登录 后参与评论