Free tools Windows power users keep installed
One-click scans. No signup required.
To diagnose an outage involving a Kubernetes controller, compare what it was asked to keep running with what the Pods, nodes, storage, and application actually did. A Deployment maintains interchangeable replicas; a DaemonSet targets matching nodes; a StatefulSet preserves Pod identity and, when configured, its association with storage. None can guarantee that the service is healthy just because its controller reports progress or its desired count is met.
No incident timeline, cluster version, application, or root cause is identified here, so this is an operational guide—not a claim that one of these controllers caused a particular outage.
As an Amazon Associate I earn from qualifying purchases.
Deployment vs. StatefulSet vs. DaemonSet
Choose a controller for the behavior the workload needs, not merely because it has a particular name. Kubernetes controllers reconcile declared desired state, but they do not all define the same kind of replica or placement.
The Tool Desk
Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →| Decision | Deployment | DaemonSet | StatefulSet |
|---|---|---|---|
| What it maintains | A requested number of generally interchangeable Pods, managed through ReplicaSets. | A Pod on each node matching its placement rules, or on a selected matching subset. | Pods with stable, unique identities and ordinal positions. |
| How placement works | The scheduler places replica Pods subject to their constraints; no particular host identity is promised. | Node labels and scheduling eligibility determine which nodes are in scope. | The scheduler places Pods while the controller preserves their identity and ordering semantics. |
| Typical fit | Stateless frontends, APIs, or interchangeable worker replicas. | Node-local facilities such as network, logging, or storage agents. | Workloads that depend on stable identity, persistent-claim association, or ordered behavior. |
| What persistence means | Deployment semantics do not themselves provide persistent storage. | DaemonSet semantics do not themselves provide persistent storage. | volumeClaimTemplates can provide a stable identity-to-claim mapping; storage availability and data safety still require separate handling. |
The Kubernetes documentation recommends a Deployment when replica scaling and rolling updates matter more than controlling which host runs a Pod. A StatefulSet gives each Pod a sticky identity; it does not make the application highly available or its data safe by itself. See the Kubernetes workload overview, DaemonSet guide, StatefulSet guide, and Apps API overview.
What to establish before calling it a controller outage
A controller outage is not a root cause by itself. A controller may be reconciling correctly while Pods fail to start, the application returns errors, endpoints disappear, or storage cannot attach. Build the incident explanation from the actual timeline and observed evidence.
#1 Best Overall
- Controller behavior: Did the controller reach its requested count, and were the Pods updated, ready, or available?
- Pod behavior: Did a Pod fail scheduling, crash, fail readiness, or become unresponsive after it was marked ready?
- Service behavior: Did traffic have healthy endpoints, and did application-level checks succeed?
- Node and storage behavior: Were the intended nodes eligible and resourced? For stateful workloads, could the required claims mount and the application recover its data?
Kubernetes can create a replacement Pod when one in a Deployment or StatefulSet fails, but replacement is not repair: it cannot fix an application defect or every storage failure. The Kubernetes self-healing documentation describes that boundary.
A step-by-step outage investigation
- Identify the owner chain. Find the affected Pod and determine whether it is owned by a ReplicaSet, DaemonSet, or StatefulSet; for a Deployment, trace through the ReplicaSet. Inspect selectors and ownership before changing resources. Overlapping selectors can make ownership behavior confusing. Useful read-only starting points include
kubectl get pod -n <namespace> <pod> -o yamlandkubectl get deploy,rs,ds,sts -n <namespace>. - Compare desired and observed state. Record requested, current, ready, and available counts, updated replicas, and controller conditions. Capture
kubectl describeoutput and Events while the failure is occurring; transient scheduling or mount errors can be lost from view later. For a Deployment,kubectl rollout status deployment/<name> -n <namespace>checks rollout progress, but it does not establish that the application serves requests correctly. - Check the controller’s scope. For a DaemonSet, list nodes and verify which match its selector and scheduling rules. Check node-label changes, taints and tolerations, and resource pressure. For a StatefulSet, correlate each ordinal with its Pod, PVC, and stable DNS identity. The relevant placement and identity behavior is described in the Kubernetes DaemonSet and StatefulSet guides.
- Separate rollout failure from runtime failure. A newly created Pod can still fail readiness, crash, or serve incorrect responses. Inspect image and configuration changes, readiness and liveness probes, Events, container logs, Service endpoints, and application-level health. A ready condition is useful evidence, not a substitute for checking the service’s actual behavior.
- Trace dependencies and storage. For a stateful workload, inspect PVC and PV binding, attachment, mount errors, the storage class and provisioner, and the application’s own data-recovery behavior. Stable Pod identity helps associate a replacement with its claim; it does not ensure a volume is available or the data is consistent.
- Bound the impact from incident evidence. Use timestamps and records to count affected replicas, nodes, or shards and identify when traffic or writes were impaired. Do not infer a blast radius from a controller’s desired count alone.
- Choose recovery based on the controller and application. A Deployment may be rolled back to a retained ReplicaSet revision; a StatefulSet rollout may require reverting its template and addressing a blocked Pod; a DaemonSet recovery must account for how broadly the new version reached eligible nodes. Follow the application’s data-recovery procedure before any data-changing action.
How rollout and rollback behavior differs
Deployment: ReplicaSet-based rolling updates
A Deployment’s RollingUpdate strategy controls how many Pods may be unavailable and how many can be added above the desired count. In the Kubernetes Authors’ current documentation retrieved in 2026, the defaults are maxUnavailable: 25% and maxSurge: 25%; percentage rounding is down for maxUnavailable and up for maxSurge. The Deployment progress-deadline default is 600 seconds. Exceeding it sets the Progressing condition to false; that condition marks stalled progress, not the underlying cause. The default retained history is 10 old ReplicaSets, while revisionHistoryLimit: 0 disables rollback. These are documented in Update a Deployment Without Downtime.
For a rollback, first inspect the rollout and available revisions with kubectl rollout history deployment/<name> -n <namespace>. If the intended prior revision is retained, kubectl rollout undo deployment/<name> -n <namespace> reverts to the previous revision; use --to-revision=<revision> to select a specific revision. Then watch kubectl rollout status and verify readiness, endpoints, and application health. A successful rollback command is not proof that traffic or data has recovered.
DaemonSet: updates across eligible nodes
A DaemonSet’s scope is the set of nodes that match its rules and can schedule the Pod. A change to node labels, taints, tolerations, or capacity can change where it runs, so count eligible nodes as well as running Pods when investigating missing or unexpected instances. Updates apply across that node scope; inspect the DaemonSet status and per-node Pod state to see how far a version change progressed. The DaemonSet documentation covers node matching and update behavior.
Rank #3
StatefulSet: ordered identity can make a rollout wait
StatefulSet Pods have ordinal identities and may be started, scaled, or updated in an order governed by the configured policy. With the usual ordered behavior, an unready Pod can prevent later rollout progress. Inspect the affected ordinal, its readiness, events, claim, and application state before trying to force progress. The Kubernetes StatefulSet guide explains stuck rollback scenarios and the importance of understanding update policy.
Feature availability is version-sensitive. The current StatefulSet documentation marks maxUnavailable as beta since Kubernetes v1.35 and a Recreate strategy as alpha since v1.37, disabled by default behind a feature gate. Do not assume either is available or enabled on an incident cluster: check that cluster’s version and feature gates first.
Why a healthy controller status can still accompany an outage
Controller convergence answers whether Kubernetes has reconciled objects toward their declared state. It does not prove that users can complete requests. A service can remain impaired even when a desired replica count is present if Pods are not ready, endpoints are wrong or absent, the application returns errors, or an external dependency is failing. Conversely, a Pod can appear healthy to Kubernetes while an application-level failure remains undetected by its probes.
Use separate evidence for each layer: controller conditions and counts for reconciliation; Pod conditions, events, and logs for runtime; Service endpoint membership for routing; and application telemetry or requests for user-visible behavior. For StatefulSets, add claim binding, volume attachment and mount evidence, and application recovery checks. Keep timestamps aligned so the incident narrative explains which condition changed first.
Best Value
What prevents a repeat—and what a PDB does not do
Prevention should address the demonstrated failure mode rather than the controller label. Depending on incident evidence, review readiness checks, rollout capacity, canary scope or StatefulSet partitions, node eligibility, storage recovery, and observability. The Deployment rolling-update settings govern its own replacement pace; they do not validate the new version’s business behavior.
A PodDisruptionBudget (PDB) is not a complete rollout safety rail: it does not constrain a Deployment or StatefulSet’s own rolling upgrade. Do not present a PDB as a limit on those workload-controller updates. The Kubernetes disruptions documentation describes this boundary.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Cleanup is not the same as data recovery
Deleting or scaling down a StatefulSet does not delete its associated volumes, and deleting the StatefulSet does not guarantee ordered, graceful Pod termination. Treat resource cleanup, Pod termination, and application data recovery as separate operations; use the workload’s documented recovery procedure before removing or reattaching storage. These lifecycle cautions are covered in the StatefulSet documentation.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
