Documentation

Overview

    Package kubelet is the package that contains the libraries that drive the Kubelet binary. The kubelet is responsible for node level pod management. It runs on each worker in the cluster.

    Index

    Constants

    View Source
    const (
    
    	// ContainerLogsDir is the location of container logs.
    	ContainerLogsDir = "/var/log/containers"
    
    	// MaxContainerBackOff is the max backoff period, exported for the e2e test
    	MaxContainerBackOff = 300 * time.Second
    
    	// ContainerGCPeriod is the period for performing container garbage collection.
    	ContainerGCPeriod = time.Minute
    	// ImageGCPeriod is the period for performing image garbage collection.
    	ImageGCPeriod = 5 * time.Minute
    )
    View Source
    const (
    	// KubeMarkMasqChain is the mark-for-masquerade chain
    	// TODO: clean up this logic in kube-proxy
    	KubeMarkMasqChain utiliptables.Chain = "KUBE-MARK-MASQ"
    
    	// KubeMarkDropChain is the mark-for-drop chain
    	KubeMarkDropChain utiliptables.Chain = "KUBE-MARK-DROP"
    
    	// KubePostroutingChain is kubernetes postrouting rules
    	KubePostroutingChain utiliptables.Chain = "KUBE-POSTROUTING"
    
    	// KubeFirewallChain is kubernetes firewall rules
    	KubeFirewallChain utiliptables.Chain = "KUBE-FIREWALL"
    )
    View Source
    const (
    	// NetworkNotReadyErrorMsg is used to describe the error that network is not ready
    	NetworkNotReadyErrorMsg = "network is not ready"
    )

    Variables

    View Source
    var (
    	// ErrNetworkUnknown indicates the network state is unknown
    	ErrNetworkUnknown = errors.New("network state unknown")
    )

    Functions

    func NewInitializedVolumePluginMgr

    func NewInitializedVolumePluginMgr(
    	kubelet *Kubelet,
    	secretManager secret.Manager,
    	configMapManager configmap.Manager,
    	tokenManager *token.Manager,
    	plugins []volume.VolumePlugin,
    	prober volume.DynamicPluginProber) (*volume.VolumePluginMgr, error)

      NewInitializedVolumePluginMgr returns a new instance of volume.VolumePluginMgr initialized with kubelets implementation of the volume.VolumeHost interface.

      kubelet - used by VolumeHost methods to expose kubelet specific parameters plugins - used to initialize volumePluginMgr

      func PreInitRuntimeService

      func PreInitRuntimeService(kubeCfg *kubeletconfiginternal.KubeletConfiguration,
      	kubeDeps *Dependencies,
      	crOptions *config.ContainerRuntimeOptions,
      	containerRuntime string,
      	runtimeCgroups string,
      	remoteRuntimeEndpoint string,
      	remoteImageEndpoint string,
      	nonMasqueradeCIDR string) error

        PreInitRuntimeService will init runtime service before RunKubelet.

        Types

        type Bootstrap

        type Bootstrap interface {
        	GetConfiguration() kubeletconfiginternal.KubeletConfiguration
        	BirthCry()
        	StartGarbageCollection()
        	ListenAndServe(address net.IP, port uint, tlsOptions *server.TLSOptions, auth server.AuthInterface, enableCAdvisorJSONEndpoints, enableDebuggingHandlers, enableContentionProfiling bool)
        	ListenAndServeReadOnly(address net.IP, port uint, enableCAdvisorJSONEndpoints bool)
        	ListenAndServePodResources()
        	Run(<-chan kubetypes.PodUpdate)
        	RunOnce(<-chan kubetypes.PodUpdate) ([]RunPodResult, error)
        }

          Bootstrap is a bootstrapping interface for kubelet, targets the initialization protocol

          type Builder

          type Builder func(kubeCfg *kubeletconfiginternal.KubeletConfiguration,
          	kubeDeps *Dependencies,
          	crOptions *config.ContainerRuntimeOptions,
          	containerRuntime string,
          	runtimeCgroups string,
          	hostnameOverride string,
          	nodeIP string,
          	providerID string,
          	cloudProvider string,
          	certDirectory string,
          	rootDirectory string,
          	registerNode bool,
          	registerWithTaints []api.Taint,
          	allowedUnsafeSysctls []string,
          	remoteRuntimeEndpoint string,
          	remoteImageEndpoint string,
          	experimentalMounterPath string,
          	experimentalKernelMemcgNotification bool,
          	experimentalCheckNodeCapabilitiesBeforeMount bool,
          	experimentalNodeAllocatableIgnoreEvictionThreshold bool,
          	minimumGCAge metav1.Duration,
          	maxPerPodContainerCount int32,
          	maxContainerCount int32,
          	masterServiceNamespace string,
          	registerSchedulable bool,
          	nonMasqueradeCIDR string,
          	keepTerminatedPodVolumes bool,
          	nodeLabels map[string]string,
          	seccompProfileRoot string,
          	bootstrapCheckpointPath string,
          	nodeStatusMaxImages int32) (Bootstrap, error)

            Builder creates and initializes a Kubelet instance

            type Dependencies

            type Dependencies struct {
            	Options []Option
            
            	// Injected Dependencies
            	Auth                    server.AuthInterface
            	CAdvisorInterface       cadvisor.Interface
            	Cloud                   cloudprovider.Interface
            	ContainerManager        cm.ContainerManager
            	DockerClientConfig      *dockershim.ClientConfig
            	EventClient             v1core.EventsGetter
            	HeartbeatClient         clientset.Interface
            	OnHeartbeatFailure      func()
            	KubeClient              clientset.Interface
            	Mounter                 mount.Interface
            	HostUtil                hostutil.HostUtils
            	OOMAdjuster             *oom.OOMAdjuster
            	OSInterface             kubecontainer.OSInterface
            	PodConfig               *config.PodConfig
            	Recorder                record.EventRecorder
            	Subpather               subpath.Interface
            	VolumePlugins           []volume.VolumePlugin
            	DynamicPluginProber     volume.DynamicPluginProber
            	TLSOptions              *server.TLSOptions
            	KubeletConfigController *kubeletconfig.Controller
            	RemoteRuntimeService    internalapi.RuntimeService
            	RemoteImageService      internalapi.ImageManagerService
            	// contains filtered or unexported fields
            }

              Dependencies is a bin for things we might consider "injected dependencies" -- objects constructed at runtime that are necessary for running the Kubelet. This is a temporary solution for grouping these objects while we figure out a more comprehensive dependency injection story for the Kubelet.

              type KillPodOptions

              type KillPodOptions struct {
              	// PodStatusFunc is the function to invoke to set pod status in response to a kill request.
              	PodStatusFunc PodStatusFunc
              	// PodTerminationGracePeriodSecondsOverride is optional override to use if a pod is being killed as part of kill operation.
              	PodTerminationGracePeriodSecondsOverride *int64
              }

                KillPodOptions are options when performing a pod update whose update type is kill.

                type Kubelet

                type Kubelet struct {
                
                	// the list of handlers to call during pod sync loop.
                	lifecycle.PodSyncLoopHandlers
                
                	// the list of handlers to call during pod sync.
                	lifecycle.PodSyncHandlers
                
                	// StatsProvider provides the node and the container stats.
                	*stats.StatsProvider
                	// contains filtered or unexported fields
                }

                  Kubelet is the main kubelet implementation.

                  func NewMainKubelet

                  func NewMainKubelet(kubeCfg *kubeletconfiginternal.KubeletConfiguration,
                  	kubeDeps *Dependencies,
                  	crOptions *config.ContainerRuntimeOptions,
                  	containerRuntime string,
                  	hostnameOverride string,
                  	nodeIP string,
                  	providerID string,
                  	cloudProvider string,
                  	certDirectory string,
                  	rootDirectory string,
                  	registerNode bool,
                  	registerWithTaints []api.Taint,
                  	allowedUnsafeSysctls []string,
                  	experimentalMounterPath string,
                  	experimentalKernelMemcgNotification bool,
                  	experimentalCheckNodeCapabilitiesBeforeMount bool,
                  	experimentalNodeAllocatableIgnoreEvictionThreshold bool,
                  	minimumGCAge metav1.Duration,
                  	maxPerPodContainerCount int32,
                  	maxContainerCount int32,
                  	masterServiceNamespace string,
                  	registerSchedulable bool,
                  	keepTerminatedPodVolumes bool,
                  	nodeLabels map[string]string,
                  	seccompProfileRoot string,
                  	bootstrapCheckpointPath string,
                  	nodeStatusMaxImages int32) (*Kubelet, error)

                    NewMainKubelet instantiates a new Kubelet object along with all the required internal modules. No initialization of Kubelet and its modules should happen here.

                    func (*Kubelet) BirthCry

                    func (kl *Kubelet) BirthCry()

                      BirthCry sends an event that the kubelet has started up.

                      func (*Kubelet) GeneratePodHostNameAndDomain

                      func (kl *Kubelet) GeneratePodHostNameAndDomain(pod *v1.Pod) (string, string, error)

                        GeneratePodHostNameAndDomain creates a hostname and domain name for a pod, given that pod's spec and annotations or returns an error.

                        func (*Kubelet) GenerateRunContainerOptions

                        func (kl *Kubelet) GenerateRunContainerOptions(pod *v1.Pod, container *v1.Container, podIP string, podIPs []string) (*kubecontainer.RunContainerOptions, func(), error)

                          GenerateRunContainerOptions generates the RunContainerOptions, which can be used by the container runtime to set parameters for launching a container.

                          func (*Kubelet) GetActivePods

                          func (kl *Kubelet) GetActivePods() []*v1.Pod

                            GetActivePods returns non-terminal pods

                            func (*Kubelet) GetAttach

                            func (kl *Kubelet) GetAttach(podFullName string, podUID types.UID, containerName string, streamOpts remotecommandserver.Options) (*url.URL, error)

                              GetAttach gets the URL the attach will be served from, or nil if the Kubelet will serve it.

                              func (*Kubelet) GetCachedMachineInfo

                              func (kl *Kubelet) GetCachedMachineInfo() (*cadvisorapiv1.MachineInfo, error)

                                GetCachedMachineInfo assumes that the machine info can't change without a reboot

                                func (*Kubelet) GetConfiguration

                                func (kl *Kubelet) GetConfiguration() kubeletconfiginternal.KubeletConfiguration

                                  GetConfiguration returns the KubeletConfiguration used to configure the kubelet.

                                  func (*Kubelet) GetExec

                                  func (kl *Kubelet) GetExec(podFullName string, podUID types.UID, containerName string, cmd []string, streamOpts remotecommandserver.Options) (*url.URL, error)

                                    GetExec gets the URL the exec will be served from, or nil if the Kubelet will serve it.

                                    func (*Kubelet) GetExtraSupplementalGroupsForPod

                                    func (kl *Kubelet) GetExtraSupplementalGroupsForPod(pod *v1.Pod) []int64

                                      GetExtraSupplementalGroupsForPod returns a list of the extra supplemental groups for the Pod. These extra supplemental groups come from annotations on persistent volumes that the pod depends on.

                                      func (*Kubelet) GetHostIP

                                      func (kl *Kubelet) GetHostIP() (net.IP, error)

                                        GetHostIP returns host IP or nil in case of error.

                                        func (*Kubelet) GetHostname

                                        func (kl *Kubelet) GetHostname() string

                                          GetHostname Returns the hostname as the kubelet sees it.

                                          func (*Kubelet) GetKubeletContainerLogs

                                          func (kl *Kubelet) GetKubeletContainerLogs(ctx context.Context, podFullName, containerName string, logOptions *v1.PodLogOptions, stdout, stderr io.Writer) error

                                            GetKubeletContainerLogs returns logs from the container TODO: this method is returning logs of random container attempts, when it should be returning the most recent attempt or all of them.

                                            func (*Kubelet) GetNode

                                            func (kl *Kubelet) GetNode() (*v1.Node, error)

                                              GetNode returns the node info for the configured node name of this Kubelet.

                                              func (*Kubelet) GetNodeConfig

                                              func (kl *Kubelet) GetNodeConfig() cm.NodeConfig

                                                GetNodeConfig returns the container manager node config.

                                                func (*Kubelet) GetPodByCgroupfs

                                                func (kl *Kubelet) GetPodByCgroupfs(cgroupfs string) (*v1.Pod, bool)

                                                  GetPodByCgroupfs provides the pod that maps to the specified cgroup, as well as whether the pod was found.

                                                  func (*Kubelet) GetPodByFullName

                                                  func (kl *Kubelet) GetPodByFullName(podFullName string) (*v1.Pod, bool)

                                                    GetPodByFullName gets the pod with the given 'full' name, which incorporates the namespace as well as whether the pod was found.

                                                    func (*Kubelet) GetPodByName

                                                    func (kl *Kubelet) GetPodByName(namespace, name string) (*v1.Pod, bool)

                                                      GetPodByName provides the first pod that matches namespace and name, as well as whether the pod was found.

                                                      func (*Kubelet) GetPodCgroupParent

                                                      func (kl *Kubelet) GetPodCgroupParent(pod *v1.Pod) string

                                                        GetPodCgroupParent gets pod cgroup parent from container manager.

                                                        func (*Kubelet) GetPodCgroupRoot

                                                        func (kl *Kubelet) GetPodCgroupRoot() string

                                                          GetPodCgroupRoot returns the listeral cgroupfs value for the cgroup containing all pods

                                                          func (*Kubelet) GetPodDNS

                                                          func (kl *Kubelet) GetPodDNS(pod *v1.Pod) (*runtimeapi.DNSConfig, error)

                                                            GetPodDNS returns DNS settings for the pod. This function is defined in kubecontainer.RuntimeHelper interface so we have to implement it.

                                                            func (*Kubelet) GetPodDir

                                                            func (kl *Kubelet) GetPodDir(podUID types.UID) string

                                                              GetPodDir returns the full path to the per-pod data directory for the specified pod. This directory may not exist if the pod does not exist.

                                                              func (*Kubelet) GetPods

                                                              func (kl *Kubelet) GetPods() []*v1.Pod

                                                                GetPods returns all pods bound to the kubelet and their spec, and the mirror pods.

                                                                func (*Kubelet) GetPortForward

                                                                func (kl *Kubelet) GetPortForward(podName, podNamespace string, podUID types.UID, portForwardOpts portforward.V4Options) (*url.URL, error)

                                                                  GetPortForward gets the URL the port-forward will be served from, or nil if the Kubelet will serve it.

                                                                  func (*Kubelet) GetRunningPods

                                                                  func (kl *Kubelet) GetRunningPods() ([]*v1.Pod, error)

                                                                    GetRunningPods returns all pods running on kubelet from looking at the container runtime cache. This function converts kubecontainer.Pod to v1.Pod, so only the fields that exist in both kubecontainer.Pod and v1.Pod are considered meaningful.

                                                                    func (*Kubelet) GetVersionInfo

                                                                    func (kl *Kubelet) GetVersionInfo() (*cadvisorapiv1.VersionInfo, error)

                                                                      GetVersionInfo returns information about the version of cAdvisor in use.

                                                                      func (*Kubelet) HandlePodAdditions

                                                                      func (kl *Kubelet) HandlePodAdditions(pods []*v1.Pod)

                                                                        HandlePodAdditions is the callback in SyncHandler for pods being added from a config source.

                                                                        func (*Kubelet) HandlePodCleanups

                                                                        func (kl *Kubelet) HandlePodCleanups() error

                                                                          HandlePodCleanups performs a series of cleanup work, including terminating pod workers, killing unwanted pods, and removing orphaned volumes/pod directories. NOTE: This function is executed by the main sync loop, so it should not contain any blocking calls.

                                                                          func (*Kubelet) HandlePodReconcile

                                                                          func (kl *Kubelet) HandlePodReconcile(pods []*v1.Pod)

                                                                            HandlePodReconcile is the callback in the SyncHandler interface for pods that should be reconciled.

                                                                            func (*Kubelet) HandlePodRemoves

                                                                            func (kl *Kubelet) HandlePodRemoves(pods []*v1.Pod)

                                                                              HandlePodRemoves is the callback in the SyncHandler interface for pods being removed from a config source.

                                                                              func (*Kubelet) HandlePodSyncs

                                                                              func (kl *Kubelet) HandlePodSyncs(pods []*v1.Pod)

                                                                                HandlePodSyncs is the callback in the syncHandler interface for pods that should be dispatched to pod workers for sync.

                                                                                func (*Kubelet) HandlePodUpdates

                                                                                func (kl *Kubelet) HandlePodUpdates(pods []*v1.Pod)

                                                                                  HandlePodUpdates is the callback in the SyncHandler interface for pods being updated from a config source.

                                                                                  func (*Kubelet) IsPodDeleted

                                                                                  func (kl *Kubelet) IsPodDeleted(uid types.UID) bool

                                                                                    IsPodDeleted returns true if the pod is deleted. For the pod to be deleted, either: 1. The pod object is deleted 2. The pod's status is evicted 3. The pod's deletion timestamp is set, and containers are not running

                                                                                    func (*Kubelet) IsPodTerminated

                                                                                    func (kl *Kubelet) IsPodTerminated(uid types.UID) bool

                                                                                      IsPodTerminated returns true if the pod with the provided UID is in a terminal phase ("Failed", "Succeeded") or has been deleted and has no running containers. This corresponds to when a pod must accept changes to its pod spec (e.g. terminating containers allow grace period to be shortened)

                                                                                      func (*Kubelet) LatestLoopEntryTime

                                                                                      func (kl *Kubelet) LatestLoopEntryTime() time.Time

                                                                                        LatestLoopEntryTime returns the last time in the sync loop monitor.

                                                                                        func (*Kubelet) ListVolumesForPod

                                                                                        func (kl *Kubelet) ListVolumesForPod(podUID types.UID) (map[string]volume.Volume, bool)

                                                                                          ListVolumesForPod returns a map of the mounted volumes for the given pod. The key in the map is the OuterVolumeSpecName (i.e. pod.Spec.Volumes[x].Name)

                                                                                          func (*Kubelet) ListenAndServe

                                                                                          func (kl *Kubelet) ListenAndServe(address net.IP, port uint, tlsOptions *server.TLSOptions, auth server.AuthInterface, enableCAdvisorJSONEndpoints, enableDebuggingHandlers, enableContentionProfiling bool)

                                                                                            ListenAndServe runs the kubelet HTTP server.

                                                                                            func (*Kubelet) ListenAndServePodResources

                                                                                            func (kl *Kubelet) ListenAndServePodResources()

                                                                                              ListenAndServePodResources runs the kubelet podresources grpc service

                                                                                              func (*Kubelet) ListenAndServeReadOnly

                                                                                              func (kl *Kubelet) ListenAndServeReadOnly(address net.IP, port uint, enableCAdvisorJSONEndpoints bool)

                                                                                                ListenAndServeReadOnly runs the kubelet HTTP server in read-only mode.

                                                                                                func (*Kubelet) PodResourcesAreReclaimed

                                                                                                func (kl *Kubelet) PodResourcesAreReclaimed(pod *v1.Pod, status v1.PodStatus) bool

                                                                                                  PodResourcesAreReclaimed returns true if all required node-level resources that a pod was consuming have been reclaimed by the kubelet. Reclaiming resources is a prerequisite to deleting a pod from the API server.

                                                                                                  func (*Kubelet) ResyncInterval

                                                                                                  func (kl *Kubelet) ResyncInterval() time.Duration

                                                                                                    ResyncInterval returns the interval used for periodic syncs.

                                                                                                    func (*Kubelet) Run

                                                                                                    func (kl *Kubelet) Run(updates <-chan kubetypes.PodUpdate)

                                                                                                      Run starts the kubelet reacting to config updates

                                                                                                      func (*Kubelet) RunInContainer

                                                                                                      func (kl *Kubelet) RunInContainer(podFullName string, podUID types.UID, containerName string, cmd []string) ([]byte, error)

                                                                                                        RunInContainer runs a command in a container, returns the combined stdout, stderr as an array of bytes

                                                                                                        func (*Kubelet) RunOnce

                                                                                                        func (kl *Kubelet) RunOnce(updates <-chan kubetypes.PodUpdate) ([]RunPodResult, error)

                                                                                                          RunOnce polls from one configuration update and run the associated pods.

                                                                                                          func (*Kubelet) ServeLogs

                                                                                                          func (kl *Kubelet) ServeLogs(w http.ResponseWriter, req *http.Request)

                                                                                                            ServeLogs returns logs of current machine.

                                                                                                            func (*Kubelet) StartGarbageCollection

                                                                                                            func (kl *Kubelet) StartGarbageCollection()

                                                                                                              StartGarbageCollection starts garbage collection threads.

                                                                                                              type OnCompleteFunc

                                                                                                              type OnCompleteFunc func(err error)

                                                                                                                OnCompleteFunc is a function that is invoked when an operation completes. If err is non-nil, the operation did not complete successfully.

                                                                                                                type Option

                                                                                                                type Option func(*Kubelet)

                                                                                                                  Option is a functional option type for Kubelet

                                                                                                                  type PodStatusFunc

                                                                                                                  type PodStatusFunc func(pod *v1.Pod, podStatus *kubecontainer.PodStatus) v1.PodStatus

                                                                                                                    PodStatusFunc is a function that is invoked to generate a pod status.

                                                                                                                    type PodWorkers

                                                                                                                    type PodWorkers interface {
                                                                                                                    	UpdatePod(options *UpdatePodOptions)
                                                                                                                    	ForgetNonExistingPodWorkers(desiredPods map[types.UID]sets.Empty)
                                                                                                                    	ForgetWorker(uid types.UID)
                                                                                                                    }

                                                                                                                      PodWorkers is an abstract interface for testability.

                                                                                                                      type ReasonCache

                                                                                                                      type ReasonCache struct {
                                                                                                                      	// contains filtered or unexported fields
                                                                                                                      }

                                                                                                                        ReasonCache stores the failure reason of the latest container start in a string, keyed by <pod_UID>_<container_name>. The goal is to propagate this reason to the container status. This endeavor is "best-effort" for two reasons:

                                                                                                                        1. The cache is not persisted.
                                                                                                                        2. We use an LRU cache to avoid extra garbage collection work. This
                                                                                                                           means that some entries may be recycled before a pod has been
                                                                                                                           deleted.
                                                                                                                        

                                                                                                                        TODO(random-liu): Use more reliable cache which could collect garbage of failed pod. TODO(random-liu): Move reason cache to somewhere better.

                                                                                                                        func NewReasonCache

                                                                                                                        func NewReasonCache() *ReasonCache

                                                                                                                          NewReasonCache creates an instance of 'ReasonCache'.

                                                                                                                          func (*ReasonCache) Get

                                                                                                                          func (c *ReasonCache) Get(uid types.UID, name string) (*ReasonItem, bool)

                                                                                                                            Get gets error reason from the cache. The return values are error reason, error message and whether an error reason is found in the cache. If no error reason is found, empty string will be returned for error reason and error message.

                                                                                                                            func (*ReasonCache) Remove

                                                                                                                            func (c *ReasonCache) Remove(uid types.UID, name string)

                                                                                                                              Remove removes error reason from the cache

                                                                                                                              func (*ReasonCache) Update

                                                                                                                              func (c *ReasonCache) Update(uid types.UID, result kubecontainer.PodSyncResult)

                                                                                                                                Update updates the reason cache with the SyncPodResult. Only SyncResult with StartContainer action will change the cache.

                                                                                                                                type ReasonItem

                                                                                                                                type ReasonItem struct {
                                                                                                                                	Err     error
                                                                                                                                	Message string
                                                                                                                                }

                                                                                                                                  ReasonItem is the cached item in ReasonCache

                                                                                                                                  type RunPodResult

                                                                                                                                  type RunPodResult struct {
                                                                                                                                  	Pod *v1.Pod
                                                                                                                                  	Err error
                                                                                                                                  }

                                                                                                                                    RunPodResult defines the running results of a Pod.

                                                                                                                                    type SyncHandler

                                                                                                                                    type SyncHandler interface {
                                                                                                                                    	HandlePodAdditions(pods []*v1.Pod)
                                                                                                                                    	HandlePodUpdates(pods []*v1.Pod)
                                                                                                                                    	HandlePodRemoves(pods []*v1.Pod)
                                                                                                                                    	HandlePodReconcile(pods []*v1.Pod)
                                                                                                                                    	HandlePodSyncs(pods []*v1.Pod)
                                                                                                                                    	HandlePodCleanups() error
                                                                                                                                    }

                                                                                                                                      SyncHandler is an interface implemented by Kubelet, for testability

                                                                                                                                      type UpdatePodOptions

                                                                                                                                      type UpdatePodOptions struct {
                                                                                                                                      	// pod to update
                                                                                                                                      	Pod *v1.Pod
                                                                                                                                      	// the mirror pod for the pod to update, if it is a static pod
                                                                                                                                      	MirrorPod *v1.Pod
                                                                                                                                      	// the type of update (create, update, sync, kill)
                                                                                                                                      	UpdateType kubetypes.SyncPodType
                                                                                                                                      	// optional callback function when operation completes
                                                                                                                                      	// this callback is not guaranteed to be completed since a pod worker may
                                                                                                                                      	// drop update requests if it was fulfilling a previous request.  this is
                                                                                                                                      	// only guaranteed to be invoked in response to a kill pod request which is
                                                                                                                                      	// always delivered.
                                                                                                                                      	OnCompleteFunc OnCompleteFunc
                                                                                                                                      	// if update type is kill, use the specified options to kill the pod.
                                                                                                                                      	KillPodOptions *KillPodOptions
                                                                                                                                      }

                                                                                                                                        UpdatePodOptions is an options struct to pass to a UpdatePod operation.

                                                                                                                                        Directories

                                                                                                                                        Path Synopsis
                                                                                                                                        Package cadvisor provides an interface for Kubelet interactions with cAdvisor.
                                                                                                                                        Package cadvisor provides an interface for Kubelet interactions with cAdvisor.
                                                                                                                                        cm
                                                                                                                                        cpumanager/topology
                                                                                                                                        Package topology contains helpers for the CPU manager.
                                                                                                                                        Package topology contains helpers for the CPU manager.
                                                                                                                                        Package config implements the pod configuration readers.
                                                                                                                                        Package config implements the pod configuration readers.
                                                                                                                                        testing
                                                                                                                                        Code generated by mockery v1.0.0
                                                                                                                                        Code generated by mockery v1.0.0
                                                                                                                                        Package custommetrics contains support for instrumenting cAdvisor to gather custom metrics from pods.
                                                                                                                                        Package custommetrics contains support for instrumenting cAdvisor to gather custom metrics from pods.
                                                                                                                                        Docker integration using k8s.io/cri-api/pkg/apis/runtime/v1alpha2/api.pb.go
                                                                                                                                        Docker integration using k8s.io/cri-api/pkg/apis/runtime/v1alpha2/api.pb.go
                                                                                                                                        cm
                                                                                                                                        network/cni/testing
                                                                                                                                        mock_cni is a mock of the `libcni.CNI` interface.
                                                                                                                                        mock_cni is a mock of the `libcni.CNI` interface.
                                                                                                                                        Package envvars is the package that build the environment variables that kubernetes provides to the containers run by it.
                                                                                                                                        Package envvars is the package that build the environment variables that kubernetes provides to the containers run by it.
                                                                                                                                        Package eviction is responsible for enforcing eviction thresholds to maintain node stability.
                                                                                                                                        Package eviction is responsible for enforcing eviction thresholds to maintain node stability.
                                                                                                                                        api
                                                                                                                                        Package images is responsible for managing lifecycle of container images.
                                                                                                                                        Package images is responsible for managing lifecycle of container images.
                                                                                                                                        Package kuberuntime contains an implementation of kubecontainer.Runtime using the interface in pkg/kubelet/v1.
                                                                                                                                        Package kuberuntime contains an implementation of kubecontainer.Runtime using the interface in pkg/kubelet/v1.
                                                                                                                                        Package leaky holds bits of kubelet that should be internal but have leaked out through bad abstractions.
                                                                                                                                        Package leaky holds bits of kubelet that should be internal but have leaked out through bad abstractions.
                                                                                                                                        Handlers for pod lifecycle events and interfaces to integrate with kubelet admission, synchronization, and eviction of pods.
                                                                                                                                        Handlers for pod lifecycle events and interfaces to integrate with kubelet admission, synchronization, and eviction of pods.
                                                                                                                                        network
                                                                                                                                        dns
                                                                                                                                        Package pleg contains types and a generic implementation of the pod lifecycle event generator.
                                                                                                                                        Package pleg contains types and a generic implementation of the pod lifecycle event generator.
                                                                                                                                        cache
                                                                                                                                        Package cache implements data structures used by the kubelet plugin manager to keep track of registered plugins.
                                                                                                                                        Package cache implements data structures used by the kubelet plugin manager to keep track of registered plugins.
                                                                                                                                        operationexecutor
                                                                                                                                        Package operationexecutor implements interfaces that enable execution of register and unregister operations with a goroutinemap so that more than one operation is never triggered on the same plugin.
                                                                                                                                        Package operationexecutor implements interfaces that enable execution of register and unregister operations with a goroutinemap so that more than one operation is never triggered on the same plugin.
                                                                                                                                        reconciler
                                                                                                                                        Package reconciler implements interfaces that attempt to reconcile the desired state of the world with the actual state of the world by triggering relevant actions (register/deregister plugins).
                                                                                                                                        Package reconciler implements interfaces that attempt to reconcile the desired state of the world with the actual state of the world by triggering relevant actions (register/deregister plugins).
                                                                                                                                        pod
                                                                                                                                        testing
                                                                                                                                        Code generated by mockery v1.0.0
                                                                                                                                        Code generated by mockery v1.0.0
                                                                                                                                        Package qos contains helper functions for quality of service.
                                                                                                                                        Package qos contains helper functions for quality of service.
                                                                                                                                        Package remote contains gRPC implementation of internalapi.RuntimeService and internalapi.ImageManagerService.
                                                                                                                                        Package remote contains gRPC implementation of internalapi.RuntimeService and internalapi.ImageManagerService.
                                                                                                                                        fake
                                                                                                                                        Package fake containers a fake gRPC implementation of internalapi.RuntimeService and internalapi.ImageManagerService.
                                                                                                                                        Package fake containers a fake gRPC implementation of internalapi.RuntimeService and internalapi.ImageManagerService.
                                                                                                                                        Package server contains functions related to serving Kubelet's external interface.
                                                                                                                                        Package server contains functions related to serving Kubelet's external interface.
                                                                                                                                        portforward
                                                                                                                                        Package portforward contains server-side logic for handling port forwarding requests.
                                                                                                                                        Package portforward contains server-side logic for handling port forwarding requests.
                                                                                                                                        remotecommand
                                                                                                                                        Package remotecommand contains functions related to executing commands in and attaching to pods.
                                                                                                                                        Package remotecommand contains functions related to executing commands in and attaching to pods.
                                                                                                                                        stats
                                                                                                                                        Package stats handles exporting Kubelet and container stats.
                                                                                                                                        Package stats handles exporting Kubelet and container stats.
                                                                                                                                        Package token implements a manager of serviceaccount tokens for pods running on the node.
                                                                                                                                        Package token implements a manager of serviceaccount tokens for pods running on the node.
                                                                                                                                        Common types in the Kubelet.
                                                                                                                                        Common types in the Kubelet.
                                                                                                                                        Package util holds utility functions.
                                                                                                                                        Package util holds utility functions.
                                                                                                                                        store
                                                                                                                                        Package store hosts a Store interface and its implementations.
                                                                                                                                        Package store hosts a Store interface and its implementations.
                                                                                                                                        cache
                                                                                                                                        Package cache implements data structures used by the kubelet volume manager to keep track of attached volumes and the pods that mounted them.
                                                                                                                                        Package cache implements data structures used by the kubelet volume manager to keep track of attached volumes and the pods that mounted them.
                                                                                                                                        populator
                                                                                                                                        Package populator implements interfaces that monitor and keep the states of the caches in sync with the "ground truth".
                                                                                                                                        Package populator implements interfaces that monitor and keep the states of the caches in sync with the "ground truth".
                                                                                                                                        reconciler
                                                                                                                                        Package reconciler implements interfaces that attempt to reconcile the desired state of the world with the actual state of the world by triggering relevant actions (attach, detach, mount, unmount).
                                                                                                                                        Package reconciler implements interfaces that attempt to reconcile the desired state of the world with the actual state of the world by triggering relevant actions (attach, detach, mount, unmount).
                                                                                                                                        Package winstats provides a client to get node and pod level stats on windows
                                                                                                                                        Package winstats provides a client to get node and pod level stats on windows