Node 14.19.0

[Jamey Saldana]

Kubernetesruns your workloadby placing containers into Pods to run on Nodes.A node may be a virtual or physical machine, depending on the cluster. Each nodeis managed by thecontrol planeand contains the services necessary to runPods.

After you create a Node object,or the kubelet on a node self-registers, the control plane checks whether the new Node objectis valid. For example, if you try to create a Node from the following JSON manifest:

Kubernetes creates a Node object internally (the representation). Kubernetes checksthat a kubelet has registered to the API server that matches the metadata.namefield of the Node. If the node is healthy (i.e. all necessary services are running),then it is eligible to run a Pod. Otherwise, that node is ignored for any cluster activityuntil it becomes healthy.

The name identifies a Node. Two Nodescannot have the same name at the same time. Kubernetes also assumes that a resource with the samename is the same object. In case of a Node, it is implicitly assumed that an instance using thesame name will have the same state (e.g. network settings, root disk contents) and attributes likenode labels. This may lead to inconsistencies if an instance was modified without changing its name.If the Node needs to be replaced or updated significantly, the existing Node object needs to beremoved from API server first and re-added after the update.

--node-ip - Optional comma-separated list of the IP addresses for the node.You can only specify a single address for each address family.For example, in a single-stack IPv4 cluster, you set this value to be the IPv4 address that thekubelet should use for the node.See configure IPv4/IPv6 dual stackfor details of running a dual-stack cluster.

As mentioned in the Node name uniqueness section,when Node configuration needs to be updated, it is a good practice to re-registerthe node with the API server. For example, if the kubelet is being restarted witha new set of --node-labels, but the same Node name is used, the change willnot take effect, as labels are only set (or modified) upon Node registration with the API server.

Pods already scheduled on the Node may misbehave or cause issues if the Nodeconfiguration will be changed on kubelet restart. For example, already runningPod may be tainted against the new labels assigned to the Node, while otherPods, that are incompatible with that Pod will be scheduled based on this newlabel. Node re-registration ensures all Pods will be drained and properlyre-scheduled.

Marking a node as unschedulable prevents the scheduler from placing new pods ontothat Node but does not affect existing Pods on the Node. This is useful as apreparatory step before a node reboot or other maintenance.

The second is keeping the node controller's internal list of nodes up to date withthe cloud provider's list of available machines. When running in a cloudenvironment and whenever a node is unhealthy, the node controller asks the cloudprovider if the VM for that node is still available. If not, the nodecontroller deletes the node from its list of nodes.

The node eviction behavior changes when a node in a given availability zonebecomes unhealthy. The node controller checks what percentage of nodes in the zoneare unhealthy (the Ready condition is Unknown or False) at the same time:

The reason these policies are implemented per availability zone is because oneavailability zone might become partitioned from the control plane while the others remainconnected. If your cluster does not span multiple cloud provider availability zones,then the eviction mechanism does not take per-zone unavailability into account.

A key reason for spreading your nodes across availability zones is so that theworkload can be shifted to healthy zones when one entire zone goes down.Therefore, if all nodes in a zone are unhealthy, then the node controller evicts atthe normal rate of --node-eviction-rate. The corner case is when all zones arecompletely unhealthy (none of the nodes in the cluster are healthy). In such acase, the node controller assumes that there is some problem with connectivitybetween the control plane and the nodes, and doesn't perform any evictions.(If there has been an outage and some nodes reappear, the node controller doesevict pods from the remaining nodes that are unhealthy or unreachable).

The node controller is also responsible for evicting pods running on nodes withNoExecute taints, unless those pods tolerate that taint.The node controller also adds taintscorresponding to node problems like node unreachable or not ready. This meansthat the scheduler won't place Pods onto unhealthy nodes.

Node objects track information about the Node's resource capacity: for example, the amountof memory available and the number of CPUs.Nodes that self register report their capacity duringregistration. If you manually add a Node, thenyou need to set the node's capacity information when you add it.

The Kubernetes scheduler ensures thatthere are enough resources for all the Pods on a Node. The scheduler checks that the sumof the requests of containers on the node is no greater than the node's capacity.That sum of requests includes all containers managed by the kubelet, but excludes anycontainers started directly by the container runtime, and also excludes anyprocesses running outside of the kubelet's control.

If you have enabled the TopologyManagerfeature gate, thenthe kubelet can use topology hints when making resource assignment decisions.See Control Topology Management Policies on a Nodefor more information.

To enable swap on a node, the NodeSwap feature gate must be enabled onthe kubelet (default is true), and the --fail-swap-on command line flag or failSwapOnconfiguration settingmust be set to false.To allow Pods to utilize swap, swapBehavior should not be set to NoSwap (which is the default behavior) in the kubelet config.

With LimitedSwap, Pods that do not fall under the Burstable QoS classification (i.e.BestEffort/Guaranteed Qos Pods) are prohibited from utilizing swap memory.To maintain the aforementioned security and node health guarantees, these Podsare not permitted to use swap memory when LimitedSwap is in effect.

It is important to note that, for containers within Burstable QoS Pods, it is possible toopt-out of swap usage by specifying memory requests that are equal to memory limits.Containers configured in this manner will not have access to swap memory.

The DOM Node interface is an abstract base class upon which many other DOM API objects are based, thus letting those object types to be used similarly and often interchangeably. As an abstract class, there is no such thing as a plain Node object. All objects that implement Node functionality are based on one of its subclasses. Most notable are Document, Element, and DocumentFragment.

In addition, every kind of DOM node is represented by an interface based on Node. These include Attr, CharacterData (which Text, Comment, CDATASection and ProcessingInstruction are all based on), and DocumentType.

In some cases, a particular feature of the base Node interface may not apply to one of its child interfaces; in that case, the inheriting node may return null or throw an exception, depending on circumstances. For example, attempting to add children to a node type that cannot have children will throw an exception.

Returns a live NodeList containing all the children of this node (including elements, text and comments). NodeList being live means that if the children of the Node change, the NodeList object is automatically updated.

A boolean indicating whether or not the Node is connected (directly or indirectly) to the context object, e.g. the Document object in the case of the normal DOM, or the ShadowRoot in the case of a shadow DOM.

Returns a string containing the name of the Node. The structure of the name will differ with the node type. E.g. An HTMLElement will contain the name of the corresponding tag, like 'AUDIO' for an HTMLAudioElement, a Text node will have the '#text' string, or a Document node will have the '#document' string.

Adds the specified childNode argument as the last child to the current node. If the argument referenced an existing node on the DOM tree, the node will be detached from its current position and attached at the new position.

If callback is provided, and it returns false when called, the current recursion level is aborted, and the function resumes execution at the last parent's level. This can be used to abort loops once a node has been found (such as searching for a text node which contains a certain string).

\n The DOM Node interface is an abstract base\n class upon which many other DOM API objects are based, thus letting those object types\n to be used similarly and often interchangeably. As an abstract class, there is\n no such thing as a plain Node object. All objects that implement\n Node functionality are based on one of its subclasses. Most notable are\n Document, Element, and DocumentFragment.\n

\n In addition, every kind of DOM node is represented by an interface based on\n Node. These include Attr, CharacterData\n (which Text, Comment, CDATASection and\n ProcessingInstruction are all based on), and DocumentType.\n

\n In some cases, a particular feature of the base Node interface may not\n apply to one of its child interfaces; in that case, the inheriting node may\n return null or throw an exception, depending on circumstances. For example,\n attempting to add children to a node type that cannot have children will throw an\n exception.\n

\n Returns a live NodeList containing all the children of this node\n (including elements, text and comments). NodeList being live means that\n if the children of the Node change, the NodeList object is\n automatically updated.\n

\n A boolean indicating whether or not the Node is connected (directly or indirectly)\n to the context object, e.g. the Document object in the case of the\n normal DOM, or the ShadowRoot in the case of a shadow DOM.\n

3a8082e126