Chapter 2. Introduction to containers and orchestration with Kubernetes 29
A DaemonSet often is used for the following tasks:
/SM590000Cluster storage daemon on each node
/SM590000Logs collection daemon on every node
/SM590000Node monitoring daemon on every node
The use of one or multiple DaemonSet depends on the complexity of the cluster and 
application.
Job
A Job creates one or more pods and ensures that a specified number of those pods 
successfully end. As pods successfully complete, the Job tracks the successful completions. 
When a specified number of successful completions is reached, the task (for example, Job) is 
complete. Deleting a Job cleans up the created pods.
A simple case is to create one Job object to reliably run one pod to completion. The Job 
object starts a new pod if the first pod fails or is deleted (for example, because of a node 
hardware failure or a node restart).
Control plan 
Pods do not, by themselves, self-heal. If a pod is scheduled to a node that fails, or if the 
scheduling operation fails, the pod is deleted; likewise, a pod does not survive an eviction 
because of a lack of resources or node maintenance. 
Kubernetes uses a higher-level abstraction, called a Controller, that handles the work of 
managing the relatively disposable pod instances. Although it is possible to use pods directly, 
it is far more common in Kubernetes to manage your pods by using a Controller. For more 
information about how Kubernetes uses Controllers to implement pod scaling and healing, 
see “Pod” on page 26 and “Controller” on page 28.
2.4.4  Cloud Native Computing Foundation
The Cloud Native Computing Foundation (CNCF) hosts critical components of the global 
technology infrastructure. For more information, see this website.
One of the projects under incubation to develop a Kubernetes Container Runtime interface is 
the Container Runtime Interface (CRI) for OCI (CRI-O). This initiative is explained in this 
section, including its architecture, benefits, and distinguishing features.
CRI-O
CRI-O is a project that was started by Red Hat in 2016 to be an open Container Initiative 
(OCI) that is based the implementation of Kubernetes CRI. This effort contributed to the 
Cloud Native Computing Foundation (CNCF). CRI-O and Kubernetes follows the same 
release cycle and dependencies.