Govur University Logo
--> --> --> -->
Govur University Logo
Sign In
...
Home → All Courses → Engineering and Technology Courses → Certified Kubernetes Administrator (CKA) → Flashcard

Explain how DaemonSets are used in Kubernetes and provide an example of a common use case.



DaemonSets in Kubernetes are used to ensure that a copy of a Pod runs on all (or some) nodes in a cluster. They are typically used to deploy system-level services or agents that need to be present on every node for monitoring, logging, or other infrastructure-related tasks. Unlike Deployments or ReplicaSets, which manage a specific number of replicas across the cluster, DaemonSets guarantee a Pod instance on each selected node. When a new node is added to the cluster, the DaemonSet automatically deploys a Pod on that node. Similarly, when a node is removed from the cluster, the DaemonSet automatically removes the Pod from that node.

How DaemonSets work:

DaemonSets use a node selector to determine which nodes should run the DaemonSet Pods. The node selector is a set of labels that the DaemonSet uses to match nodes. By default, if no node selector is specified, the DaemonSet will schedule a Pod on all nodes in the cluster.

The DaemonSet controller is responsible for ensuring that the desired number of Pods are running on the selected nodes. It monitors the nodes in the cluster and creates or deletes Pods as needed to maintain the desired state.

Common use cases for DaemonSets:

Logging agents: DaemonSets are commonly used to deploy logging agents, such as Fluentd or Elasticsearch, to collect logs from all nodes in the cluster.
Monitoring agents: DaemonSets are also used to deploy monitoring agents, such as Prometheus Node Exporter or Datadog Agent, to collect metrics from all nodes in the cluster.
Network plugins: DaemonSets can be used to deploy network plugins, such as Calico or Weave Net, to provide networking functionality to the cluster.
Storage agents: DaemonSets can be used to deploy storage agents, such as Rook or Ceph, to provide distributed storage to the cluster.
Security agents: DaemonSets can be used to deploy security agents, such as Falco or Aqua Security, to monitor the cluster for security threats.

Example: Deploying a Fluentd logging agent using a DaemonSet:

Let's say you want to deploy a Fluentd logging agent to collect logs from all nodes in your Kubernetes cluster and forward them to an Elasticsearch cluster. You can use a DaemonSet to achieve this.

1. Create a DaemonSet manifest:

```yaml
apiVersion: apps/v1
kind: DaemonSet
metadata:
name: fluentd
labels:
app: fluentd
spec:
selector:
matchLabels:
app: fluentd
template:
metadata:
labels:
app: fluentd
spec:
containers:
- name: fluentd
image: fluent/fluentd:latest
env:
- name: FLUENTD_ES_HOST
value: elasticsearch.default.svc.cluster.local
- name: FLUENTD_ES_PORT
value: "9200"
volumeMounts:
- name: varlog
mountPath: /var/log
- name: varlibdockercontainers
mountPath: /var/lib/docker/containers
readOnly: true
volumes:
- name: varlog
hostPath:
path: /var/log
- name: varlibdockercontainers
hostPath:
path: /var/lib/docker/containers
```

In this example:

apiVersion: Specifies the API version for the DaemonSet (`apps/v1`).
kind: Specifies the type of resource (`DaemonSet`).
metadata.name: Specifies the name of the DaemonSet (`fluentd`).
spec.selector.matchLabels: Specifies the labels that the DaemonSet will use to select the target Pods (`app: fluentd`).
spec.template: Defines the Pod template for the DaemonSet.
spec.template.spec.containers: Defines the containers that will run in the Pod.
spec.template.spec.containers.env: Defines the environment variables for the container. In this example, we are setting the FLUENTD_ES_HOST and FLUENTD_ES_PORT environment variables to configure Fluentd to forward logs to an Elasticsearch cluster.
spec.template.spec.containers.volumeMounts: Defines the volume mounts for the container. In this example, we are mounting the /var/log and /var/lib/docker/containers directories from the host node into the container.
spec.template.spec.volumes: Defines the volumes that will be used by the container. In this example, we are using hostPath volumes to mount the /var/log and /var/lib/docker/containers directories from the host node.

2. Apply the DaemonSet:

Save the above YAML as `fluentd-daemonset.yaml` and apply it using kubectl:

```bash
kubectl apply -f fluentd-daemonset.yaml
```

This will create the Fluentd DaemonSet in your Kubernetes cluster. The DaemonSet controller will automatically deploy a Fluentd Pod on each node in the cluster.

3. Verify the DaemonSet:

You can verify that the DaemonSet is working correctly by checking the status of the DaemonSet and the Pods that it is managing.

```bash
kubectl get daemonsets
kubectl get pods -l app=fluentd
```

The kubectl get daemonsets command will show you the status of the DaemonSet, including the number of desired, current, and ready Pods. The kubectl get pods -l app=fluentd command will show you the status of the Fluentd Pods that are running on each node in the cluster.

Key considerations:

Node selectors: Use node selectors to target specific nodes for DaemonSet Pods. This can be useful if you want to run different DaemonSets on different types of nodes.
Resource limits: Set resource limits for DaemonSet Pods to prevent them from consuming too many resources on the nodes.
Rolling updates: DaemonSets support rolling updates, which allow you to update the DaemonSet Pods without downtime.

In summary, DaemonSets are a powerful tool for deploying system-level services or agents to all nodes in a Kubernetes cluster. They provide a reliable and automated way to ensure that these services are always running and up-to-date.



Redundant Elements