kubelet

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
• Variables
• func NewInitializedVolumePluginMgr(kubelet *Kubelet, secretManager secret.Manager, ...) (*volume.VolumePluginMgr, error)
• func PreInitRuntimeService(kubeCfg *kubeletconfiginternal.KubeletConfiguration, kubeDeps *Dependencies, ...) error
• type Bootstrap
• type Dependencies
• type DockerOptions
• type KillPodOptions
• type Kubelet
  • func NewMainKubelet(kubeCfg *kubeletconfiginternal.KubeletConfiguration, kubeDeps *Dependencies, ...) (*Kubelet, error)
  • func (kl *Kubelet) BirthCry()
  • func (kl *Kubelet) GeneratePodHostNameAndDomain(pod *v1.Pod) (string, string, error)
  • func (kl *Kubelet) GenerateRunContainerOptions(pod *v1.Pod, container *v1.Container, podIP string, podIPs []string) (*kubecontainer.RunContainerOptions, func(), error)
  • func (kl *Kubelet) GetActivePods() []*v1.Pod
  • func (kl *Kubelet) GetAttach(podFullName string, podUID types.UID, containerName string, ...) (*url.URL, error)
  • func (kl *Kubelet) GetCachedMachineInfo() (*cadvisorapiv1.MachineInfo, error)
  • func (kl *Kubelet) GetCgroupCPUAndMemoryStats(cgroupName string, updateStats bool) (*statsapi.ContainerStats, error)
  • func (kl *Kubelet) GetCgroupStats(cgroupName string, updateStats bool) (*statsapi.ContainerStats, *statsapi.NetworkStats, error)
  • func (kl *Kubelet) GetConfiguration() kubeletconfiginternal.KubeletConfiguration
  • func (kl *Kubelet) GetContainerInfo(podFullName string, uid types.UID, containerName string, ...) (*cadvisorapi.ContainerInfo, error)
  • func (kl *Kubelet) GetExec(podFullName string, podUID types.UID, containerName string, cmd []string, ...) (*url.URL, error)
  • func (kl *Kubelet) GetExtraSupplementalGroupsForPod(pod *v1.Pod) []int64
  • func (kl *Kubelet) GetHostIPs() ([]net.IP, error)
  • func (kl *Kubelet) GetHostname() string
  • func (kl *Kubelet) GetKubeletContainerLogs(ctx context.Context, podFullName, containerName string, ...) error
  • func (kl *Kubelet) GetNode() (*v1.Node, error)
  • func (kl *Kubelet) GetNodeConfig() cm.NodeConfig
  • func (kl *Kubelet) GetPodByCgroupfs(cgroupfs string) (*v1.Pod, bool)
  • func (kl *Kubelet) GetPodByFullName(podFullName string) (*v1.Pod, bool)
  • func (kl *Kubelet) GetPodByName(namespace, name string) (*v1.Pod, bool)
  • func (kl *Kubelet) GetPodCgroupParent(pod *v1.Pod) string
  • func (kl *Kubelet) GetPodCgroupRoot() string
  • func (kl *Kubelet) GetPodDNS(pod *v1.Pod) (*runtimeapi.DNSConfig, error)
  • func (kl *Kubelet) GetPodDir(podUID types.UID) string
  • func (kl *Kubelet) GetPods() []*v1.Pod
  • func (kl *Kubelet) GetPortForward(podName, podNamespace string, podUID types.UID, ...) (*url.URL, error)
  • func (kl *Kubelet) GetRawContainerInfo(containerName string, req *cadvisorapi.ContainerInfoRequest, ...) (map[string]*cadvisorapi.ContainerInfo, error)
  • func (kl *Kubelet) GetRequestedContainersInfo(containerName string, options cadvisorv2.RequestOptions) (map[string]*cadvisorapiv1.ContainerInfo, error)
  • func (kl *Kubelet) GetRunningPods() ([]*v1.Pod, error)
  • func (kl *Kubelet) GetVersionInfo() (*cadvisorapiv1.VersionInfo, error)
  • func (kl *Kubelet) HandlePodAdditions(pods []*v1.Pod)
  • func (kl *Kubelet) HandlePodCleanups() error
  • func (kl *Kubelet) HandlePodReconcile(pods []*v1.Pod)
  • func (kl *Kubelet) HandlePodRemoves(pods []*v1.Pod)
  • func (kl *Kubelet) HandlePodSyncs(pods []*v1.Pod)
  • func (kl *Kubelet) HandlePodUpdates(pods []*v1.Pod)
  • func (kl *Kubelet) ImageFsStats() (*statsapi.FsStats, error)
  • func (kl *Kubelet) LatestLoopEntryTime() time.Time
  • func (kl *Kubelet) ListBlockVolumesForPod(podUID types.UID) (map[string]volume.BlockVolume, bool)
  • func (kl *Kubelet) ListPodCPUAndMemoryStats() ([]statsapi.PodStats, error)
  • func (kl *Kubelet) ListPodStats() ([]statsapi.PodStats, error)
  • func (kl *Kubelet) ListPodStatsAndUpdateCPUNanoCoreUsage() ([]statsapi.PodStats, error)
  • func (kl *Kubelet) ListVolumesForPod(podUID types.UID) (map[string]volume.Volume, bool)
  • func (kl *Kubelet) ListenAndServe(kubeCfg *kubeletconfiginternal.KubeletConfiguration, ...)
  • func (kl *Kubelet) ListenAndServePodResources()
  • func (kl *Kubelet) ListenAndServeReadOnly(address net.IP, port uint)
  • func (kl *Kubelet) PodResourcesAreReclaimed(pod *v1.Pod, status v1.PodStatus) bool
  • func (kl *Kubelet) ResyncInterval() time.Duration
  • func (kl *Kubelet) RlimitStats() (*statsapi.RlimitStats, error)
  • func (kl *Kubelet) RootFsStats() (*statsapi.FsStats, error)
  • func (kl *Kubelet) Run(updates <-chan kubetypes.PodUpdate)
  • func (kl *Kubelet) RunInContainer(podFullName string, podUID types.UID, containerName string, cmd []string) ([]byte, error)
  • func (kl *Kubelet) RunOnce(updates <-chan kubetypes.PodUpdate) ([]RunPodResult, error)
  • func (kl *Kubelet) ServeLogs(w http.ResponseWriter, req *http.Request)
  • func (kl *Kubelet) StartGarbageCollection()
• type OnCompleteFunc
• type Option
• type PodStatusFunc
• type PodWorkType
• type PodWorkerState
• type PodWorkers
• type ReasonCache
  • func NewReasonCache() *ReasonCache
  • func (c *ReasonCache) Get(uid types.UID, name string) (*ReasonItem, bool)
  • func (c *ReasonCache) Remove(uid types.UID, name string)
  • func (c *ReasonCache) Update(uid types.UID, result kubecontainer.PodSyncResult)
• type ReasonItem
• type RunPodResult
• type SyncHandler
• type UpdatePodOptions

Constants

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
)

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"
)

const (
	PodInitializing   = "PodInitializing"
	ContainerCreating = "ContainerCreating"
)

Container state reason list

const (
	// NetworkNotReadyErrorMsg is used to describe the error that network is not ready
	NetworkNotReadyErrorMsg = "network is not ready"
)

Variables

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(kubeCfg *kubeletconfiginternal.KubeletConfiguration, tlsOptions *server.TLSOptions, auth server.AuthInterface)
	ListenAndServeReadOnly(address net.IP, port uint)
	ListenAndServePodResources()
	Run(<-chan kubetypes.PodUpdate)
	RunOnce(<-chan kubetypes.PodUpdate) ([]RunPodResult, error)
}

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

type Dependencies

type Dependencies struct {
	Options []Option

	// Injected Dependencies
	Auth                    server.AuthInterface
	CAdvisorInterface       cadvisor.Interface
	Cloud                   cloudprovider.Interface
	ContainerManager        cm.ContainerManager
	DockerOptions           *DockerOptions
	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 DockerOptions

type DockerOptions struct {
	DockerEndpoint            string
	RuntimeRequestTimeout     time.Duration
	ImagePullProgressDeadline time.Duration
}

DockerOptions contains docker specific configuration. Importantly, since it lives outside of `dockershim`, it should not depend on the `docker/docker` client library.

type KillPodOptions

type KillPodOptions struct {
	// CompletedCh is closed when the kill request completes (syncTerminatingPod has completed
	// without error) or if the pod does not exist, or if the pod has already terminated. This
	// could take an arbitrary amount of time to be closed, but is never left open once
	// CouldHaveRunningContainers() returns false.
	CompletedCh chan<- struct{}
	// Evict is true if this is a pod triggered eviction - once a pod is evicted some resources are
	// more aggressively reaped than during normal pod operation (stopped containers).
	Evict bool
	// PodStatusFunc is invoked (if set) and overrides the status of the pod at the time the pod is killed.
	// The provided status is populated from the latest state.
	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.
	StatsProvider *stats.Provider
	// 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,
	hostname string,
	hostnameOverridden bool,
	nodeName types.NodeName,
	nodeIPs []net.IP,
	providerID string,
	cloudProvider string,
	certDirectory string,
	rootDirectory string,
	imageCredentialProviderConfigFile string,
	imageCredentialProviderBinDir string,
	registerNode bool,
	registerWithTaints []api.Taint,
	allowedUnsafeSysctls []string,
	experimentalMounterPath string,
	kernelMemcgNotification bool,
	experimentalCheckNodeCapabilitiesBeforeMount bool,
	experimentalNodeAllocatableIgnoreEvictionThreshold bool,
	minimumGCAge metav1.Duration,
	maxPerPodContainerCount int32,
	maxContainerCount int32,
	masterServiceNamespace string,
	registerSchedulable bool,
	keepTerminatedPodVolumes bool,
	nodeLabels map[string]string,
	seccompProfileRoot string,
	nodeStatusMaxImages int32,
	seccompDefault bool,
) (*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 pods that have been admitted to the kubelet that are not fully terminated. This is mapped to the "desired state" of the kubelet - what pods should be running.

WARNING: Currently this list does not include pods that have been force deleted but may still be terminating, which means resources assigned to those pods during admission may still be in use. See https://github.com/kubernetes/kubernetes/issues/104824

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) GetCgroupCPUAndMemoryStats

func (kl *Kubelet) GetCgroupCPUAndMemoryStats(cgroupName string, updateStats bool) (*statsapi.ContainerStats, error)

GetCgroupCPUAndMemoryStats is delegated to StatsProvider, which implements stats.Provider interface

func (*Kubelet) GetCgroupStats

func (kl *Kubelet) GetCgroupStats(cgroupName string, updateStats bool) (*statsapi.ContainerStats, *statsapi.NetworkStats, error)

GetCgroupStats is delegated to StatsProvider, which implements stats.Provider interface

func (*Kubelet) GetConfiguration

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

GetConfiguration returns the KubeletConfiguration used to configure the kubelet.

func (*Kubelet) GetContainerInfo

func (kl *Kubelet) GetContainerInfo(podFullName string, uid types.UID, containerName string, req *cadvisorapi.ContainerInfoRequest) (*cadvisorapi.ContainerInfo, error)

GetContainerInfo is delegated to StatsProvider, which implements stats.Provider interface

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) GetHostIPs

func (kl *Kubelet) GetHostIPs() ([]net.IP, error)

GetHostIPs returns host IPs 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) GetRawContainerInfo

func (kl *Kubelet) GetRawContainerInfo(containerName string, req *cadvisorapi.ContainerInfoRequest, subcontainers bool) (map[string]*cadvisorapi.ContainerInfo, error)

GetRawContainerInfo is delegated to StatsProvider, which implements stats.Provider interface

func (*Kubelet) GetRequestedContainersInfo

func (kl *Kubelet) GetRequestedContainersInfo(containerName string, options cadvisorv2.RequestOptions) (map[string]*cadvisorapiv1.ContainerInfo, error)

GetRequestedContainersInfo returns container info.

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. No config changes are sent to pod workers while this method is executing which means no new pods can appear. 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) ImageFsStats

func (kl *Kubelet) ImageFsStats() (*statsapi.FsStats, error)

ImageFsStats is delegated to StatsProvider, which implements stats.Provider interface

func (*Kubelet) LatestLoopEntryTime

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

LatestLoopEntryTime returns the last time in the sync loop monitor.

func (*Kubelet) ListBlockVolumesForPod

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

ListBlockVolumesForPod 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) ListPodCPUAndMemoryStats

func (kl *Kubelet) ListPodCPUAndMemoryStats() ([]statsapi.PodStats, error)

ListPodCPUAndMemoryStats is delegated to StatsProvider, which implements stats.Provider interface

func (*Kubelet) ListPodStats

func (kl *Kubelet) ListPodStats() ([]statsapi.PodStats, error)

ListPodStats is delegated to StatsProvider, which implements stats.Provider interface

func (*Kubelet) ListPodStatsAndUpdateCPUNanoCoreUsage

func (kl *Kubelet) ListPodStatsAndUpdateCPUNanoCoreUsage() ([]statsapi.PodStats, error)

ListPodStatsAndUpdateCPUNanoCoreUsage is delegated to StatsProvider, which implements stats.Provider interface

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(kubeCfg *kubeletconfiginternal.KubeletConfiguration, tlsOptions *server.TLSOptions,
	auth server.AuthInterface)

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)

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) RlimitStats

func (kl *Kubelet) RlimitStats() (*statsapi.RlimitStats, error)

RlimitStats is delegated to StatsProvider, which implements stats.Provider interface

func (*Kubelet) RootFsStats

func (kl *Kubelet) RootFsStats() (*statsapi.FsStats, error)

RootFsStats is delegated to StatsProvider, which implements stats.Provider interface

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(podStatus *v1.PodStatus)

PodStatusFunc is a function that is invoked to override the pod status when a pod is killed.

type PodWorkType

type PodWorkType int

PodWorkType classifies the three phases of pod lifecycle - setup (sync), teardown of containers (terminating), cleanup (terminated).

const (
	// SyncPodWork is when the pod is expected to be started and running.
	SyncPodWork PodWorkType = iota
	// TerminatingPodWork is when the pod is no longer being set up, but some
	// containers may be running and are being torn down.
	TerminatingPodWork
	// TerminatedPodWork indicates the pod is stopped, can have no more running
	// containers, and any foreground cleanup can be executed.
	TerminatedPodWork
)

type PodWorkerState

type PodWorkerState int

PodWorkType classifies the status of pod as seen by the pod worker - setup (sync), teardown of containers (terminating), cleanup (terminated), or recreated with the same UID (kill -> create while terminating)

const (
	// SyncPod is when the pod is expected to be started and running.
	SyncPod PodWorkerState = iota
	// TerminatingPod is when the pod is no longer being set up, but some
	// containers may be running and are being torn down.
	TerminatingPod
	// TerminatedPod indicates the pod is stopped, can have no more running
	// containers, and any foreground cleanup can be executed.
	TerminatedPod
	// TerminatedAndRecreatedPod indicates that after the pod was terminating a
	// request to recreate the pod was received. The pod is terminated and can
	// now be restarted by sending a create event to the pod worker.
	TerminatedAndRecreatedPod
)

type PodWorkers

type PodWorkers interface {
	// UpdatePod notifies the pod worker of a change to a pod, which will then
	// be processed in FIFO order by a goroutine per pod UID. The state of the
	// pod will be passed to the syncPod method until either the pod is marked
	// as deleted, it reaches a terminal phase (Succeeded/Failed), or the pod
	// is evicted by the kubelet. Once that occurs the syncTerminatingPod method
	// will be called until it exits successfully, and after that all further
	// UpdatePod() calls will be ignored for that pod until it has been forgotten
	// due to significant time passing. A pod that is terminated will never be
	// restarted.
	UpdatePod(options UpdatePodOptions)
	// SyncKnownPods removes workers for pods that are not in the desiredPods set
	// and have been terminated for a significant period of time. Once this method
	// has been called once, the workers are assumed to be fully initialized and
	// subsequent calls to ShouldPodContentBeRemoved on unknown pods will return
	// true. It returns a map describing the state of each known pod worker.
	SyncKnownPods(desiredPods []*v1.Pod) map[types.UID]PodWorkerState

	// IsPodKnownTerminated returns true if the provided pod UID is known by the pod
	// worker to be terminated. If the pod has been force deleted and the pod worker
	// has completed termination this method will return false, so this method should
	// only be used to filter out pods from the desired set such as in admission.
	//
	// Intended for use by the kubelet config loops, but not subsystems, which should
	// use ShouldPod*().
	IsPodKnownTerminated(uid types.UID) bool
	// CouldHaveRunningContainers returns true before the pod workers have synced,
	// once the pod workers see the pod (syncPod could be called), and returns false
	// after the pod has been terminated (running containers guaranteed stopped).
	//
	// Intended for use by the kubelet config loops, but not subsystems, which should
	// use ShouldPod*().
	CouldHaveRunningContainers(uid types.UID) bool
	// IsPodTerminationRequested returns true when pod termination has been requested
	// until the termination completes and the pod is removed from config. This should
	// not be used in cleanup loops because it will return false if the pod has already
	// been cleaned up - use ShouldPodContainersBeTerminating instead. Also, this method
	// may return true while containers are still being initialized by the pod worker.
	//
	// Intended for use by the kubelet sync* methods, but not subsystems, which should
	// use ShouldPod*().
	IsPodTerminationRequested(uid types.UID) bool

	// ShouldPodContainersBeTerminating returns false before pod workers have synced,
	// or once a pod has started terminating. This check is similar to
	// ShouldPodRuntimeBeRemoved but is also true after pod termination is requested.
	//
	// Intended for use by subsystem sync loops to avoid performing background setup
	// after termination has been requested for a pod. Callers must ensure that the
	// syncPod method is non-blocking when their data is absent.
	ShouldPodContainersBeTerminating(uid types.UID) bool
	// ShouldPodRuntimeBeRemoved returns true if runtime managers within the Kubelet
	// should aggressively cleanup pod resources that are not containers or on disk
	// content, like attached volumes. This is true when a pod is not yet observed
	// by a worker after the first sync (meaning it can't be running yet) or after
	// all running containers are stopped.
	// TODO: Once pod logs are separated from running containers, this method should
	// be used to gate whether containers are kept.
	//
	// Intended for use by subsystem sync loops to know when to start tearing down
	// resources that are used by running containers. Callers should ensure that
	// runtime content they own is not required for post-termination - for instance
	// containers are required in docker to preserve pod logs until after the pod
	// is deleted.
	ShouldPodRuntimeBeRemoved(uid types.UID) bool
	// ShouldPodContentBeRemoved returns true if resource managers within the Kubelet
	// should aggressively cleanup all content related to the pod. This is true
	// during pod eviction (when we wish to remove that content to free resources)
	// as well as after the request to delete a pod has resulted in containers being
	// stopped (which is a more graceful action). Note that a deleting pod can still
	// be evicted.
	//
	// Intended for use by subsystem sync loops to know when to start tearing down
	// resources that are used by non-deleted pods. Content is generally preserved
	// until deletion+removal_from_etcd or eviction, although garbage collection
	// can free content when this method returns false.
	ShouldPodContentBeRemoved(uid types.UID) bool
	// IsPodForMirrorPodTerminatingByFullName returns true if a static pod with the
	// provided pod name is currently terminating and has yet to complete. It is
	// intended to be used only during orphan mirror pod cleanup to prevent us from
	// deleting a terminating static pod from the apiserver before the pod is shut
	// down.
	IsPodForMirrorPodTerminatingByFullName(podFullname string) bool
}

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 {
	// The type of update (create, update, sync, kill).
	UpdateType kubetypes.SyncPodType
	// StartTime is an optional timestamp for when this update was created. If set,
	// when this update is fully realized by the pod worker it will be recorded in
	// the PodWorkerDuration metric.
	StartTime time.Time
	// Pod to update. Required.
	Pod *v1.Pod
	// MirrorPod is the mirror pod if Pod is a static pod. Optional when UpdateType
	// is kill or terminated.
	MirrorPod *v1.Pod
	// RunningPod is a runtime pod that is no longer present in config. Required
	// if Pod is nil, ignored if Pod is set.
	RunningPod *kubecontainer.Pod
	// KillPodOptions is used to override the default termination behavior of the
	// pod or to update the pod status after an operation is completed. Since a
	// pod can be killed for multiple reasons, PodStatusFunc is invoked in order
	// and later kills have an opportunity to override the status (i.e. a preemption
	// may be later turned into an eviction).
	KillPodOptions *KillPodOptions
}

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