Package options contains all of the primary arguments for a kubelet.



    This section is empty.


    This section is empty.


    func AddGlobalFlags

    func AddGlobalFlags(fs *pflag.FlagSet)

      AddGlobalFlags explicitly registers flags that libraries (glog, verflag, etc.) register against the global flagsets from "flag" and "". We do this in order to prevent unwanted flags from leaking into the Kubelet's flagset.

      func AddKubeletConfigFlags

      func AddKubeletConfigFlags(mainfs *pflag.FlagSet, c *kubeletconfig.KubeletConfiguration)

        AddKubeletConfigFlags adds flags for a specific kubeletconfig.KubeletConfiguration to the specified FlagSet

        func NewContainerRuntimeOptions

        func NewContainerRuntimeOptions() *config.ContainerRuntimeOptions

          NewContainerRuntimeOptions will create a new ContainerRuntimeOptions with default values.

          func NewKubeletConfiguration

          func NewKubeletConfiguration() (*kubeletconfig.KubeletConfiguration, error)

            NewKubeletConfiguration will create a new KubeletConfiguration with default values

            func ValidateKubeletFlags

            func ValidateKubeletFlags(f *KubeletFlags) error

              ValidateKubeletFlags validates Kubelet's configuration flags and returns an error if they are invalid.

              func ValidateKubeletServer

              func ValidateKubeletServer(s *KubeletServer) error

                ValidateKubeletServer validates configuration of KubeletServer and returns an error if the input configuration is invalid.


                type KubeletFlags

                type KubeletFlags struct {
                	KubeConfig          string
                	BootstrapKubeconfig string
                	// Insert a probability of random errors during calls to the master.
                	ChaosChance float64
                	// Crash immediately, rather than eating panics.
                	ReallyCrashForTesting bool
                	// TODO(mtaufen): It is increasingly looking like nobody actually uses the
                	//                Kubelet's runonce mode anymore, so it may be a candidate
                	//                for deprecation and removal.
                	// If runOnce is true, the Kubelet will check the API server once for pods,
                	// run those in addition to the pods specified by static pod files, and exit.
                	RunOnce bool
                	// enableServer enables the Kubelet's server
                	EnableServer bool
                	// HostnameOverride is the hostname used to identify the kubelet instead
                	// of the actual hostname.
                	HostnameOverride string
                	// NodeIP is IP address of the node.
                	// If set, kubelet will use this IP address for the node.
                	NodeIP string
                	// This flag, if set, sets the unique id of the instance that an external provider (i.e. cloudprovider)
                	// can use to identify a specific node
                	ProviderID string
                	// Container-runtime-specific options.
                	// certDirectory is the directory where the TLS certs are located (by
                	// default /var/run/kubernetes). If tlsCertFile and tlsPrivateKeyFile
                	// are provided, this flag will be ignored.
                	CertDirectory string
                	// cloudProvider is the provider for cloud services.
                	// +optional
                	CloudProvider string
                	// cloudConfigFile is the path to the cloud provider configuration file.
                	// +optional
                	CloudConfigFile string
                	// rootDirectory is the directory path to place kubelet files (volume
                	// mounts,etc).
                	RootDirectory string
                	// The Kubelet will use this directory for checkpointing downloaded configurations and tracking configuration health.
                	// The Kubelet will create this directory if it does not already exist.
                	// The path may be absolute or relative; relative paths are under the Kubelet's current working directory.
                	// Providing this flag enables dynamic kubelet configuration.
                	// To use this flag, the DynamicKubeletConfig feature gate must be enabled.
                	DynamicConfigDir cliflag.StringFlag
                	// The Kubelet will load its initial configuration from this file.
                	// The path may be absolute or relative; relative paths are under the Kubelet's current working directory.
                	// Omit this flag to use the combination of built-in default configuration values and flags.
                	KubeletConfigFile string
                	// registerNode enables automatic registration with the apiserver.
                	RegisterNode bool
                	// registerWithTaints are an array of taints to add to a node object when
                	// the kubelet registers itself. This only takes effect when registerNode
                	// is true and upon the initial registration of the node.
                	RegisterWithTaints []core.Taint
                	// WindowsService should be set to true if kubelet is running as a service on Windows.
                	// Its corresponding flag only gets registered in Windows builds.
                	WindowsService bool
                	// EXPERIMENTAL FLAGS
                	// Whitelist of unsafe sysctls or sysctl patterns (ending in *).
                	// +optional
                	AllowedUnsafeSysctls []string
                	// containerized should be set to true if kubelet is running in a container.
                	Containerized bool
                	// remoteRuntimeEndpoint is the endpoint of remote runtime service
                	RemoteRuntimeEndpoint string
                	// remoteImageEndpoint is the endpoint of remote image service
                	RemoteImageEndpoint string
                	// experimentalMounterPath is the path of mounter binary. Leave empty to use the default mount path
                	ExperimentalMounterPath string
                	// If enabled, the kubelet will integrate with the kernel memcg notification to determine if memory eviction thresholds are crossed rather than polling.
                	// +optional
                	ExperimentalKernelMemcgNotification bool
                	// This flag, if set, enables a check prior to mount operations to verify that the required components
                	// (binaries, etc.) to mount the volume are available on the underlying node. If the check is enabled
                	// and fails the mount operation fails.
                	ExperimentalCheckNodeCapabilitiesBeforeMount bool
                	// This flag, if set, will avoid including `EvictionHard` limits while computing Node Allocatable.
                	// Refer to [Node Allocatable]( doc for more information.
                	ExperimentalNodeAllocatableIgnoreEvictionThreshold bool
                	// Node Labels are the node labels to add when registering the node in the cluster
                	NodeLabels map[string]string
                	// volumePluginDir is the full path of the directory in which to search
                	// for additional third party volume plugins
                	VolumePluginDir string
                	// lockFilePath is the path that kubelet will use to as a lock file.
                	// It uses this file as a lock to synchronize with other kubelet processes
                	// that may be running.
                	LockFilePath string
                	// ExitOnLockContention is a flag that signifies to the kubelet that it is running
                	// in "bootstrap" mode. This requires that 'LockFilePath' has been set.
                	// This will cause the kubelet to listen to inotify events on the lock file,
                	// releasing it and exiting when another process tries to open that file.
                	ExitOnLockContention bool
                	// seccompProfileRoot is the directory path for seccomp profiles.
                	SeccompProfileRoot string
                	// bootstrapCheckpointPath is the path to the directory containing pod checkpoints to
                	// run on restore
                	BootstrapCheckpointPath string
                	// NodeStatusMaxImages caps the number of images reported in Node.Status.Images.
                	// This is an experimental, short-term flag to help with node scalability.
                	NodeStatusMaxImages int32
                	// DEPRECATED FLAGS
                	// minimumGCAge is the minimum age for a finished container before it is
                	// garbage collected.
                	MinimumGCAge metav1.Duration
                	// maxPerPodContainerCount is the maximum number of old instances to
                	// retain per container. Each container takes up some disk space.
                	MaxPerPodContainerCount int32
                	// maxContainerCount is the maximum number of old instances of containers
                	// to retain globally. Each container takes up some disk space.
                	MaxContainerCount int32
                	// masterServiceNamespace is The namespace from which the kubernetes
                	// master services should be injected into pods.
                	MasterServiceNamespace string
                	// registerSchedulable tells the kubelet to register the node as
                	// schedulable. Won't have any effect if register-node is false.
                	// DEPRECATED: use registerWithTaints instead
                	RegisterSchedulable bool
                	// nonMasqueradeCIDR configures masquerading: traffic to IPs outside this range will use IP masquerade.
                	NonMasqueradeCIDR string
                	// This flag, if set, instructs the kubelet to keep volumes from terminated pods mounted to the node.
                	// This can be useful for debugging volume related issues.
                	KeepTerminatedPodVolumes bool
                	// allowPrivileged enables containers to request privileged mode.
                	// Defaults to true.
                	AllowPrivileged bool
                	// hostNetworkSources is a comma-separated list of sources from which the
                	// Kubelet allows pods to use of host network. Defaults to "*". Valid
                	// options are "file", "http", "api", and "*" (all sources).
                	HostNetworkSources []string
                	// hostPIDSources is a comma-separated list of sources from which the
                	// Kubelet allows pods to use the host pid namespace. Defaults to "*".
                	HostPIDSources []string
                	// hostIPCSources is a comma-separated list of sources from which the
                	// Kubelet allows pods to use the host ipc namespace. Defaults to "*".
                	HostIPCSources []string

                  KubeletFlags contains configuration flags for the Kubelet. A configuration field should go in KubeletFlags instead of KubeletConfiguration if any of these are true: - its value will never, or cannot safely be changed during the lifetime of a node, or - its value cannot be safely shared between nodes at the same time (e.g. a hostname);

                  KubeletConfiguration is intended to be shared between nodes.

                  In general, please try to avoid adding flags or configuration fields, we already have a confusingly large amount of them.

                  func NewKubeletFlags

                  func NewKubeletFlags() *KubeletFlags

                    NewKubeletFlags will create a new KubeletFlags with default values

                    func (*KubeletFlags) AddFlags

                    func (f *KubeletFlags) AddFlags(mainfs *pflag.FlagSet)

                      AddFlags adds flags for a specific KubeletFlags to the specified FlagSet

                      type KubeletServer

                      type KubeletServer struct {

                        KubeletServer encapsulates all of the parameters necessary for starting up a kubelet. These can either be set via command line or directly.

                        func NewKubeletServer

                        func NewKubeletServer() (*KubeletServer, error)

                          NewKubeletServer will create a new KubeletServer with default values.

                          func (*KubeletServer) AddFlags

                          func (s *KubeletServer) AddFlags(fs *pflag.FlagSet)

                            AddFlags adds flags for a specific KubeletServer to the specified FlagSet