Kubernetes Errors

The AKS policy addon error occurs when Azure Policy fails to install, initialize, or enforce policies on your Kubernetes cluster. Common causes include missing prerequisites, Azure Policy addon not enabled, gatekeeper pod failures, or policy constraint violations.

This error occurs when a PersistentVolumeClaim cannot find any matching PersistentVolume in the cluster. Common causes include missing StorageClass configuration, no static PVs available, or mismatched capacity/access modes between PVC and PV.

Container runtime errors indicate the kubelet cannot communicate with Docker, containerd, or another CRI runtime. Pods fail to start and nodes become degraded when the runtime is unavailable or misconfigured.

The "CPU resource exceeded" error occurs when a pod uses more CPU than its limit. Kubernetes throttles CPU-limited containers, causing performance degradation and timeouts. This prevents a single pod from consuming all node CPU but requires proper limit configuration.

A Kubernetes eks pod identity association failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes eks irsa assume role failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A fencing error occurs when a node is unresponsive or partitioned from the cluster, and Kubernetes cannot determine if pods should be evicted. Fencing prevents "split brain" scenarios where multiple copies of stateful pods run simultaneously. Fencing is critical for stateful applications and storage systems.

A floating IP unavailable error occurs in cloud providers (Vultr, DigitalOcean, Hetzner) when a reserved IP address cannot be assigned to a LoadBalancer service. This prevents external traffic from reaching the service, blocking ingress connectivity.

A Kubernetes eks oidc provider not found error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes eks node not joining error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes eks security group not found error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A PersistentVolumeClaim references a StorageClass that doesn't exist in the cluster. This prevents dynamic volume provisioning and leaves PVCs in a Pending state indefinitely. Fix by creating the missing StorageClass or correcting the PVC's storageClassName reference.

The "Failed Pod Hook" error occurs when a container lifecycle hook (PostStart or PreStop) fails or times out. PostStart hooks run after the container starts, while PreStop hooks run before termination. A failed hook blocks the pod from becoming Ready or prevents graceful shutdown.

A CSI (Container Storage Interface) driver required for volume provisioning or mounting is not available on worker nodes. This occurs when the driver DaemonSet isn't deployed, pods failed to start, or node taints prevent scheduling. Fix by deploying the driver via Helm, checking node scheduling constraints, and verifying driver registration.

The "Feature Gate Not Enabled" error occurs when you try to use a Kubernetes feature that requires enabling a feature gate on the API server or kubelet.

A container running as a non-root user cannot access a volume because it's owned by root or a different user. Fix by adding fsGroup to the pod's securityContext to grant group-based access, or use init containers to change permissions before the main container starts.

A PersistentVolume is already bound to another pod and cannot be accessed by a new pod due to access mode restrictions. ReadWriteOnce (RWO) volumes permit only one pod to mount them. Fix by using ReadWriteMany access mode, limiting pods to single replicas, or switching to StatefulSets.

A Kubernetes istio mtls mismatch error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes istio 503 nr error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A pod references a ConfigMap that doesn't exist or is in a different namespace. ConfigMaps are namespace-scoped; pods can only access ConfigMaps in their own namespace. Fix by creating the ConfigMap in the correct namespace or marking the reference as optional to allow pod startup.

A Kubernetes istio 503 uc error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A pod references a specific key within a Secret that doesn't exist. Secret keys are case-sensitive and must match exactly. Fix by verifying key names in the Secret match pod references, or marking the reference as optional to allow startup.

A Kubernetes envoy upstream reset error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes istio sidecar injection failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A PersistentVolume with ReadWriteOnce access mode is already exclusively attached to one node, preventing a new pod on a different node from mounting it. This commonly occurs after node failures, failed pod restarts, or Deployment rolling updates. Fix by cleaning up stale VolumeAttachments, scaling the Deployment, or switching to StatefulSets.

A pod references a specific key within a ConfigMap that doesn't exist. ConfigMap keys are case-sensitive and must match exactly. Fix by verifying key names in the ConfigMap match pod references, or marking the reference as optional.

AGIC (Application Gateway Ingress Controller) errors occur when the controller fails to synchronize Kubernetes ingress resources with Azure Application Gateway. This results in ingress resources not being applied to the gateway, causing 502 Bad Gateway errors. Common causes include permission issues, incorrect ingress annotations, or AGIC pod failures.

A pod references a Secret via secretKeyRef that doesn't exist, is in a different namespace, or has an incorrect key name. Fix by creating the missing Secret in the correct namespace, verifying key names match exactly (case-sensitive), or marking the reference as optional.

A pod references a ConfigMap via configMapKeyRef that doesn't exist, is in a different namespace, or has an incorrect key. Fix by creating the ConfigMap in the correct namespace, verifying key names match exactly, or marking the reference as optional.

A container fails startup probe checks repeatedly, causing it to restart continuously (CrashLoopBackOff). Startup probes verify the application has started before liveness and readiness probes begin. Fix by increasing failureThreshold, adjusting periodSeconds, or ensuring the health endpoint is accessible during startup.

A container fails health checks repeatedly, triggering kubelet to restart it continuously. This causes CrashLoopBackOff state. Fix by increasing initialDelaySeconds to allow startup, using startup probes for slow-starting apps, or tuning timeouts and thresholds.

A Kubernetes eks iam auth failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

Azure AD integration failures in AKS occur when Microsoft Entra ID authentication cannot authorize users or service principals to access the cluster. This results in "Unauthorized" errors when running kubectl commands. Common causes include expired credentials, RBAC configuration mismatches, and managed identity setup issues.

Helm cannot find or read the values YAML file specified with the -f flag.

A Kubernetes coredns timeout error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes coredns nxdomain error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

Health check probes timeout because the container cannot respond within the configured timeoutSeconds (default 1 second). This occurs when the application is slow, under resource pressure, or implementing expensive health checks. Fix by increasing timeoutSeconds, allocating more resources, or using startup probes.

A Kubernetes coredns servfail error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

Error when image does not exist in registry

The FailedPostStartHook error occurs when a container's postStart lifecycle hook fails to execute successfully, preventing the container from starting properly.

ErrImageNeverPull occurs when imagePullPolicy is set to Never but the required image does not exist locally on the node. Load the image into your cluster or change the pull policy.

A Kubernetes tls secret invalid error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

Exit code 1 is a generic application error indicating the container process failed. Check container logs for the specific error message and fix the underlying application or configuration issue.

A pod cannot reach a Kubernetes Service because the Service doesn't exist, is in a different namespace, or has no endpoints. Applications can't connect to the service DNS name. Fix by creating the Service, verifying label selectors match pod labels, or using fully qualified DNS names for cross-namespace access.

This error occurs when you try to create pods in a namespace that has reached its ResourceQuota limit for maximum number of pods.

A Kubernetes operator reconcile error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

Exit code 126 means the command was found but cannot be executed, typically due to missing execute permissions. Add chmod +x to your Dockerfile or fix file permissions.

Exit code 128 indicates a container startup failure—the runtime could not execute the specified command. Verify the command exists, check for mount issues, or fix invalid exit codes in scripts.

A pod cannot connect to a service because the service port is wrong, the application isn't listening, or there are no healthy endpoints. The connection is refused at the network level, typically because the service has no running pods or the pod is listening on a different port than configured. Fix by verifying endpoints, application ports, and readiness probes.

A Kubernetes crd not found error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

Network packets cannot reach the destination host because network policies block traffic, IP forwarding is disabled on nodes, or pods are isolated by CNI configuration. Unlike connection refused, the packet never reaches the application. Fix by reviewing network policies, enabling IP forwarding, or configuring CNI correctly.

This scheduling error occurs when no available nodes satisfy the pod's anti-affinity constraints, often because all nodes already have pods that conflict with the rules.

A Kubernetes duplicate key error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

The Ingress controller cannot reach healthy backend pods because they are failing health checks, restarting, or not listening on the expected port. A 502 indicates the gateway received an invalid response from the upstream service, typically due to readiness probe failures, port mismatches, or pods crashing. Fix by ensuring backend pods are healthy and ports match the service configuration.

A Kubernetes invalid apiversion error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

The FailedAttachVolume error occurs when Kubernetes cannot attach a persistent volume to a node, typically because the volume is already attached elsewhere or the cloud provider operation failed.

The Ingress controller cannot find any healthy backend endpoints because no pods are ready, the service doesn't exist, or pod counts are zero. A 503 indicates the service has no available endpoints to route traffic to, requiring either pod startup, service creation, or endpoint verification. Fix by ensuring pods are running and ready, and verifying service endpoints exist.

A Kubernetes missing required field error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

This error occurs when a pod references a volume that doesn't exist, typically due to a deleted PersistentVolume, unbound PVC, or failed dynamic provisioning.

A Kubernetes unknown field error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

Azure CNI overlay networking fails due to Network Security Group (NSG) misconfigurations, SNAT routing issues, or IP address exhaustion. Pods cannot communicate across nodes or reach external services. Fix by reviewing NSG rules, ensuring pod CIDR capacity, and verifying CNI plugin initialization.

The Kubernetes API server is overwhelmed by excessive requests, returning 429 (Too Many Requests) errors. Causes include clients making unoptimized LIST queries, etcd performance degradation, or insufficient inflight request capacity. Fix by identifying offending clients, tuning etcd, and enabling API Priority and Fairness (APF).

A Kubernetes invalid resource error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

HPA (Horizontal Pod Autoscaler) cannot scale pods because metrics are unavailable, pods lack resource requests, or scaling constraints prevent replica changes. The HPA reports "FailedGetResourceMetric" error when Metrics Server is missing or metrics data is unavailable. Fix by installing Metrics Server, adding resource requests, or ensuring pods are ready.

A Kubernetes conflict resourceversion error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

Admission webhooks timeout because the webhook handler is slow, unavailable, or the cluster cannot reach it. Webhooks block pod creation/updates, causing deployments to fail. Fix by optimizing webhook performance, adding replicas behind a service, or adjusting timeout values.

Kubernetes cluster certificates expire after 1 year by default, causing API server, kubelet, etcd, and other control plane components to become unavailable. The cluster becomes inaccessible when certificates expire. Fix by renewing certificates proactively or implementing automatic rotation.

The ACME challenge failed error occurs when cert-manager cannot validate domain ownership with Let's Encrypt during TLS certificate provisioning. This typically blocks certificate issuance and renewal, preventing HTTPS traffic. Common causes include DNS propagation issues, HTTP endpoint accessibility problems, and rate limiting violations.

A 504 Gateway Timeout in Kubernetes Ingress occurs when the NGINX controller cannot receive a response from backend services before the timeout expires. This commonly happens with slow applications, database operations, or when timeout settings don't match your workload requirements.

A 404 Not Found error in Kubernetes Ingress indicates that the routing configuration is incorrect or the backend service cannot be reached. This typically happens due to mismatched service names, missing rewrite rules, or incorrect path configurations in your Ingress resource.

The "IngressClass not found" error occurs when your Ingress resource references an IngressClass that doesn't exist in your cluster. This typically happens when the Ingress controller (like NGINX) hasn't been installed or when there's a mismatch between the configured class name and the actual controller.

The "Unauthorized" error in Kubernetes indicates that authentication to the API server has failed, usually because your credentials are missing, invalid, or expired. This is different from "Forbidden" which means you're authenticated but lack permissions.

The "Forbidden: User cannot create resource in namespace" error occurs when your Kubernetes user, service account, or IAM role lacks the necessary RBAC permissions to create resources in a specific namespace. This is a permissions issue that requires proper role and binding configuration.

MemoryPressure indicates the kubelet node has insufficient memory available for workload scheduling. Pods cannot be scheduled or existing pods are evicted when available memory falls below the eviction threshold. This is a resource allocation issue that prevents cluster utilization.

The MinimumReplicasUnavailable condition indicates your Kubernetes Deployment cannot maintain the minimum required number of available replicas. This blocks rolling updates and signals underlying issues with pod scheduling, resource availability, or container health.

ReplicaFailure indicates that the Kubernetes ReplicaSet controller cannot create or maintain the desired number of pod replicas. This is usually caused by resource constraints, image pull errors, or security policy violations that prevent pod creation.

API server timeout errors occur when kubectl or cluster components cannot reach the Kubernetes API server within the expected time. This happens due to control plane overload, network latency, or misconfigured timeouts and can block deployments and cluster operations.

The "Waiting for rollout to finish" message appears when kubectl rollout status cannot complete a deployment rollout within the expected timeframe. This blocks CI/CD pipelines and indicates your deployment is stuck due to pod failures, resource constraints, or timeout issues.

GKE networking fails to initialize when VPC, subnet, or firewall configuration is incomplete. Nodes cannot obtain IP addresses, pods cannot communicate, and networking components fail to start.

AKS virtual node errors occur when pods fail to run on Azure Container Instances (ACI) due to networking, permissions, or quota issues. These errors typically involve authentication failures, container group quota limits, or misconfigured subnets.

Halo (Cilium policy) enforcement fails when network policies are misconfigured, endpoint selectors do not match, or policy syntax is invalid. Pod networking becomes restricted or broken.

The "deployment not found" error occurs when kubectl cannot locate a Deployment resource. This is usually caused by a namespace mismatch, typo in the deployment name, connected to the wrong cluster, or the deployment was deleted.

Alertmanager notification failures occur when alerts cannot be delivered to configured receivers like email, Slack, or webhooks. Common causes include SMTP misconfiguration, network connectivity issues, invalid receiver endpoints, TLS certificate errors, and timeout problems.

The "Job completions is immutable" error occurs when you attempt to modify the `.spec.completions` field on an already-created Kubernetes Job. This field specifies required pod completions and cannot be changed after creation.

Pod cannot read/write hostPath volume due to permission mismatch. Container UID/GID does not match directory ownership on host. Write operations fail despite mounted path.

AKS Defender errors occur when Microsoft Defender for Containers fails to deploy, authenticate, or send security data to Azure. Common causes include disabled feature flags, network connectivity issues, cgroup v2 incompatibility, and invalid cluster configurations.

HorizontalPodAutoscaler cannot access metric data because metrics-server is not running, pod metrics are incomplete, or the metrics API is not responding.

The node.kubernetes.io/unreachable taint is applied when the Kubernetes control plane cannot communicate with a worker node and the node status becomes "Unknown". This causes pod eviction and prevents new pods from scheduling on that node.

Pod readiness/liveness HTTP probes timeout when application does not respond quickly enough. Probes fail to reach the health check endpoint within the timeout window.

The "node not found" error occurs when kubelet fails to register with the Kubernetes API server during cluster initialization or after a node restart. This prevents the node from joining the cluster and scheduling pods.

A Kubernetes object not found error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

PLEG (Pod Lifecycle Event Generator) is a critical kubelet component that monitors container runtime state. When PLEG becomes unhealthy, the node transitions to NotReady and prevents pod scheduling. This is usually caused by container runtime latency, high pod density, or resource exhaustion.

HTTPS liveness/readiness probes fail due to invalid or self-signed certificates. Probes cannot verify the server certificate, causing health checks to fail.

A StatefulSet shows "not ready" status when its pods fail to reach the Running and Ready state. This blocks orderly pod deployment since StatefulSets wait for each pod to be fully ready before starting the next one. The issue typically stems from storage failures, resource constraints, health check misconfigurations, or application startup problems.

The HPA (Horizontal Pod Autoscaler) error about unable to get CPU metrics indicates the Metrics Server is not installed, misconfigured, or pods lack resource requests. Without metrics, HPA cannot determine if pods need more replicas.

Error when no node has enough available CPU

The "namespaces not found" error occurs when kubectl tries to access a Kubernetes namespace that doesn't exist. This typically happens due to typos in namespace names, misconfigured kubeconfig contexts, or the namespace being deleted.

The "Events rate limit exceeded" error occurs when the API server generates more events per second than the rate limiter allows. This typically happens during pod creation storms, node failures, or configuration updates, causing recent events to be dropped and hindering troubleshooting.

The kubectl i/o timeout error indicates kubectl cannot reach the Kubernetes API server. This is usually caused by API server being down, network connectivity issues, incorrect kubeconfig, or firewall blocking access.

The etcd context deadline exceeded error indicates API requests are timing out when communicating with the etcd cluster. This is critical because etcd stores all Kubernetes cluster data and its unavailability affects the entire cluster.

A Kubernetes cluster proportional autoscaler error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

The etcd leader changed error indicates the etcd cluster detected a leadership change during operation. While occasional changes are normal, frequent changes signal network issues, slow disk performance, or resource constraints that prevent timely heartbeats.

The etcdserver no leader error indicates the etcd cluster lost quorum and cannot elect a leader. This is critical because the cluster cannot make any changes: no new pods can be scheduled and configurations cannot be updated.

The port 6443 in use error during kubeadm init means another process or container is already binding to the Kubernetes API server port. This typically happens from a previous cluster installation that wasn't fully cleaned up.

A Kubernetes mutating webhook error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

Pod termination exceeds the grace period timeout when containers ignore SIGTERM, processes hang during shutdown, or finalization takes too long. Pods force-terminate without graceful cleanup.

A Kubernetes validating webhook error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

This error occurs when a container image reference has invalid format.

Error when image pull repeatedly fails

The Kubernetes scheduler cannot place a pod on any node because resource constraints, node selectors, taints, or infrastructure issues prevent valid placement. Pods remain in Pending state indefinitely. Fix by scaling the cluster, relaxing scheduling constraints, or ensuring nodes have required labels and resources.

Error when Ingress controller cannot reach backend

A Kubernetes webhook connection refused error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

This kubectl authentication error occurs when your client cannot successfully authenticate with the Kubernetes API server. Causes include expired tokens, invalid kubeconfig credentials, IAM role mismatches, or expired certificates.

A PVC has entered the Lost phase, meaning it lost its binding to the underlying PersistentVolume. This is a critical error indicating data may be inaccessible or lost. It occurs when the PV is deleted while PVC still references it, storage backend fails, or finalizers block cleanup. Recovery is difficult; prevention through backups is essential.

Error when Ingress controller pod not running

A container is running but fails health checks, so Kubernetes removes it from service endpoints. Traffic doesn't route to the pod but the container isn't restarted. Fix by increasing initialDelaySeconds, using startup probes, tuning timeouts, or ensuring the application's health endpoint works correctly.

A pod fails to pull a container image from a private registry because the registry credentials are missing, incorrect, or the repository doesn't exist. This occurs with private registries (Azure ACR, AWS ECR, etc.) that require authentication. Fix by creating proper imagePullSecrets with correct credentials.

Health check probes fail because they cannot connect to the container on the specified port. The container may not be listening on that port, initialDelaySeconds is too low, or the container isn't starting properly. Fix by increasing initialDelaySeconds, verifying the port is correct, or checking why the application failed to start.

Pod or service DNS lookups fail because CoreDNS is not running, network policies block DNS traffic (UDP/53), or the service doesn't exist. Applications cannot reach services by hostname, requiring fully qualified domain names or direct IP addresses as workarounds. Fix by verifying CoreDNS is running, checking network policies, and ensuring proper DNS configuration.

CrashLoopBackOff indicates a container is repeatedly crashing and restarting. Kubernetes applies exponential backoff delays between restarts while you diagnose the underlying application or configuration issue.

ErrImagePull is the initial failure when Kubernetes cannot pull a container image. It immediately precedes ImagePullBackOff and indicates authentication, network, or image reference problems.

OOMKilled (exit code 137) means the Linux kernel terminated your container for exceeding its memory limit. Increase memory limits or optimize your application memory usage.

This error occurs when Kubernetes cannot authenticate with a container registry to pull a private image. Fix it by creating imagePullSecrets with valid registry credentials and referencing them in your pod spec or service account.

Exit code 0 means the container completed successfully, but Deployments restart completed containers causing CrashLoopBackOff. Use Jobs for one-time tasks or ensure your container runs a long-lived process.

Exit code 127 means "command not found"—the binary or script specified in your container command does not exist. Verify the path, install missing dependencies, or fix your Dockerfile.

Exit code 143 means the container received SIGTERM for graceful shutdown. This is normal during scaling, updates, or pod deletion. Ensure your application handles SIGTERM properly.

This critical error indicates your Kubernetes cluster's etcd database has exceeded its storage quota (default 2GB). etcd enters read-only mode, preventing any cluster modifications until space is reclaimed through compaction and defragmentation.

Unknown status means Kubernetes lost contact with the node running the pod. Check node health, network connectivity, and kubelet status. The pod may still be running but unreachable.

Evicted pods were terminated by kubelet due to node resource pressure (memory, disk, or ephemeral storage). Set proper resource limits, clean up disk space, or scale your cluster.

Pods stuck in ContainerCreating cannot start containers due to image pull issues, volume mount failures, or CNI network problems. Check events for the specific cause.

CreateContainerConfigError means Kubernetes cannot generate container configuration, usually due to missing ConfigMaps, Secrets, or invalid references. Verify all referenced resources exist.

RunInitError (Init:RunContainerError) occurs when an init container fails to start or execute. Fix the init container configuration, image, or command before the main containers can run.

PostStartHookError occurs when a container lifecycle postStart hook fails. The hook failure kills the container, causing restart loops. Fix the hook command or remove it.

PreStopHookError occurs when a preStop lifecycle hook fails during pod termination. The hook failure is logged but termination continues. Ensure hooks complete within the grace period.

FailedScheduling means no node can accept your pod due to resource constraints, taints, affinity rules, or other scheduling requirements. Check the specific reason in pod events.

Node selector mismatch means no nodes have the labels your pod requires. Add labels to nodes, fix nodeSelector in pod spec, or use node affinity for flexibility.

Taint/toleration mismatch means nodes are tainted but your pod lacks matching tolerations. Add tolerations to your pod or remove taints from nodes.

The RoleBinding referenced by your pod or service account does not exist. Fix by ensuring the RoleBinding is created in the correct namespace, verify its name matches what's referenced, and confirm the Role it points to exists before the RoleBinding.

A Kubernetes webhook denied error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

This error occurs when a container's memory limit exceeds the namespace LimitRange maximum. Fix it by lowering the memory limit to stay within the maximum constraint or requesting a LimitRange adjustment.

A Kubernetes helm hook failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

The EKS CNI (Container Network Interface) plugin fails to initialize on worker nodes, preventing pods from getting IP addresses and cluster nodes from becoming ready. This typically results from incompatible add-on versions, missing IAM permissions, network connectivity issues, or incorrect network configuration.

ClusterRole not found errors occur when a ClusterRoleBinding references a ClusterRole that does not exist or has been deleted. This is typically caused by creation order issues, typos in role names, or attempting to reference cluster roles across namespaces incorrectly.

Error when HTTP to HTTPS redirect fails

A deployment failed to progress within the specified timeout (progressDeadlineSeconds). This indicates the pods are not becoming ready, likely due to image pull failures, readiness probe failures, resource constraints, or slow application startup. Diagnose the root cause by checking pod logs, then adjust the deadline or fix the underlying issue.

Error when Ingress host has invalid format

StatefulSet partition controls phased rolling updates by specifying which pod ordinals receive new versions. Misconfigured partitions can prevent updates from propagating or leave StatefulSets stuck in non-ready states. Fix by correctly configuring the updateStrategy.rollingUpdate.partition value relative to replicas.

An ArgoCD application shows "Degraded" status when one or more of its managed resources are failing their health checks. This is distinct from sync failures and indicates the deployed application is not running healthily. Fix by identifying which resources are unhealthy and addressing the underlying issues (failed deployments, unavailable pods, misconfigured services).

Error when init container takes too long

ArgoCD components are missing when the installation is incomplete or CRDs are not properly installed. This occurs when namespace-scoped deployments lack CustomResourceDefinitions (CRDs) or core components (API server, controller, repo server) fail to start. Fix by installing ArgoCD with all required manifests and verifying all pods are running.

The "AppArmor profile error" occurs when a Kubernetes Pod references an AppArmor profile that is not loaded on the node. This error is caused by missing profile definitions, profile loading failures, or API version mismatches between how the profile is specified and what the cluster supports.

ArgoCD fails to connect to a managed cluster due to incorrect credentials, network blocking, or invalid kubeconfig. The cluster status shows "Unknown" or connection attempts timeout. Fix by verifying the cluster URL, updating kubeconfig credentials, checking firewall rules between ArgoCD and the cluster, and ensuring RBAC permissions.

An init container exited with a non-zero status, preventing the Pod from starting. Debug by checking init container logs, exit codes, and command syntax to identify the failure.

Error when CNI plugin fails to install

AKS disk CSI errors occur when Azure Disk volumes fail to attach, mount, or provision in Kubernetes clusters. Common causes include incorrect RBAC permissions, disk resource group mismatches, case-sensitive URI format issues, or CSI driver installation problems. Fix by verifying service principal permissions, checking disk resource groups, validating volume configurations, and ensuring the Azure Disk CSI driver is properly deployed.

PIDPressure indicates the node has exhausted its maximum number of processes (PIDs). New processes and containers cannot start when the PID limit is reached. This typically affects nodes running many concurrent processes or containers without proper isolation.

Error when imagePullSecret is invalid

Port conflicts occur when multiple services or pods attempt to bind to the same port on a node. This prevents pod startup and service exposure. Common with NodePort services, DaemonSets, and multi-host deployments.

Port conflicts between multiple services or pods prevent proper service routing and pod scheduling. This occurs when services attempt to use the same port or when hostPort bindings collide, disrupting traffic flow and application availability.

A sync loop hang occurs when the kubelet's main reconciliation loop becomes blocked or unresponsive. The node stops processing pod changes, leaving pods in inconsistent states and blocking cluster operations.

Error when manifest specifies non-existent kind

Temporary failure errors indicate transient problems during pod startup (network timeouts, brief API server unavailability, container image pull delays). These usually resolve with retry, but repeated failures suggest persistent issues.

An unresponsive kubelet means the node no longer communicates with the API server or cannot process requests. The node becomes NotReady, pods cannot be scheduled, and existing pods may be evicted. This is a critical operational issue.

Empty label selectors occur when a service, deployment, or other resource specifies labels that match no pods. This leaves services with no endpoints, deployments without replicas, and resource orphaned from workloads.

AKS kubelet identity errors occur when the cluster cannot authenticate or access resources due to missing permissions or misconfigured managed identity assignments. Learn how to diagnose identity issues and restore proper RBAC configuration.

Error when label value violates naming rules

Kustomize overlay errors occur when base directory references are incorrect, circular dependencies exist, or overlay structure is malformed. Fix by verifying base paths in kustomization.yaml, ensuring correct directory structure, and using kustomize build to preview changes before applying.

GKE cluster upgrade fails when nodes timeout during upgrade, pod eviction fails, or control plane migration hangs. Clusters revert to original version or get stuck mid-upgrade due to insufficient capacity or blocking workloads.

ArgoCD reports resources as orphaned when they exist in the cluster but are not tracked by any ArgoCD application. This happens after manual resource creation or application definition changes. Sync the application or adopt orphaned resources.

Azure Files CSI driver errors prevent mounting file shares in AKS clusters. Common causes include driver registration failures, storage account access issues, FIPS node pool incompatibilities, and network connectivity problems. Fixes range from checking driver installation to configuring proper network access and role-based access control.

RBAC ClusterRoleBinding or RoleBinding references a group that does not exist in authentication provider. Pod access control fails because group membership cannot be verified.

AKS managed identity errors occur when pods fail to authenticate to Azure services because the managed identity is not properly configured, accessible, or lacks required RBAC permissions. These errors prevent your applications from accessing Azure resources like Key Vault, databases, and storage.

Alertmanager config errors occur when the configuration YAML is invalid or contains syntax issues, preventing Alertmanager from parsing the configuration file. Common causes include YAML indentation errors, missing required fields, and invalid parameter values.

Pod using hostNetwork cannot start because the required port is already bound on the node. Another process (pod, daemon, system service) is using the port.

An ArgoCD Application cannot be deleted because its finalizer is preventing deletion. The resources-finalizer.argocd.argoproj.io finalizer blocks deletion until cascade delete completes or is removed. Fix by removing the finalizer, checking for stuck resources, or patching the Application metadata.

Pod fails to mount hostPath volume because the directory does not exist on the node. Pod cannot start without the required mount path.

HorizontalPodAutoscaler cannot calculate desired replica count due to missing metrics, invalid metric values, or computation errors. Scaling decisions fail.

DaemonSet pods may timeout during creation or get stuck in not-ready state due to node issues, resource constraints, or broken webhooks. Fix by checking node health, reviewing admission controller logs, ensuring sufficient resources, and resolving node taints.

DaemonSet rolling updates get stuck when new pods can't be scheduled, are crashing, or old pods won't terminate. Fix by debugging pod failures, freeing node resources, fixing the new template, or manually rolling out the update.

HorizontalPodAutoscaler will not scale down pods even when demand decreases. Scale-down is disabled by policy, stabilization window, or autoscaling config.

This error indicates that a job is in a suspended or failed state and is not executing. This typically happens when the job is explicitly suspended, has exceeded retry limits, or has persistent pod failures.

Hubble errors occur when network observability components fail to start or cannot communicate. Fix by verifying Hubble deployment, checking Hubble Relay connectivity, and reviewing certificate configuration.

Capability errors occur when requesting Linux capabilities denied by security policies. Fix by reviewing Pod Security Standards, dropping unnecessary capabilities, and adding only required ones.

This error indicates that a pod created by a job has failed to complete successfully, typically due to application errors, resource issues, or configuration problems.

ArgoCD project permission denied errors occur when users or service accounts lack RBAC permissions to create or manage applications. This is typically resolved by configuring project roles, policies, and token-based access for CI/CD pipelines.

Sync failures occur when ArgoCD cannot apply manifests to the cluster. Common causes include CRD not found, invalid YAML, missing permissions, and cluster connectivity issues.

This error occurs when the job cleanup strategy (TTL configuration) is invalid or misconfigured, preventing the job from being properly managed or garbage collected.

Pod CPU limits cause the kernel to throttle container processes when they exceed configured limits. Unlike memory, throttled pods continue running but with reduced performance. Fix by adjusting CPU requests/limits, enabling HPA, or removing inappropriate limits.

This error occurs when applying a JSONPatch to a Kubernetes resource that has invalid syntax or attempts invalid operations, typically when using kubectl patch.

This error occurs when Kubernetes OIDC authentication fails to connect to or validate tokens from a Keycloak identity provider, typically due to misconfiguration, network issues, or certificate problems.

Cilium agent not ready errors occur during initialization or when dependencies fail. Fix by checking pod logs, verifying kernel compatibility, and ensuring sufficient system resources.

This error occurs when trying to create a Kubernetes resource of a type that is not available or registered in the API server, typically due to missing CRD or unsupported API version.

LimitRange validation failures occur when pod resource specifications violate namespace policies. Pods cannot be created until their resources comply with minimum/maximum constraints.

Repository not found errors occur when ArgoCD cannot access the Git repository URL. Common causes include incorrect URLs, missing GitHub App authorization, Helm vs Git repository confusion, and missing repository credentials.

This error occurs when Kubernetes encryption at rest fails due to KMS provider issues, typically when the external key management system is unavailable or misconfigured.

A Kubernetes eks aws auth configmap error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

This error occurs when the API server cannot authenticate to a kubelet on a worker node, preventing node communication and pod operations.

Your kubectl cannot connect to the Kubernetes API server. This prevents any cluster management operations.

Your kubectl cannot verify the API server certificate because it doesn't trust the signing authority. This is typically a CA certificate mismatch.

Your kubectl cannot establish a TLS connection to the API server within the timeout period. This indicates network latency, slow server, or SSL/TLS certificate issues.

The kubelet service on a node is not running, preventing the node from being part of the cluster.

This error occurs when the kubelet device manager fails to manage devices like GPUs, typically due to plugin issues or device unavailability.

The container runtime (Docker, containerd, or cri-o) is not running on your node, preventing kubelet from starting Pods.

The kubeadm join token used to add a node to the cluster is invalid, expired, or was malformed.

During kubeadm init, the control plane failed to initialize within the timeout period, usually because critical system Pods are not starting.

The CA certificate hash provided to kubeadm join does not match the actual cluster CA, preventing secure node authentication.

Helm cannot find the release you're trying to upgrade, rollback, or delete. This usually means the release was never installed or was in a different namespace.

This error occurs when the kubelet becomes unresponsive and stops processing pod operations, typically due to deadlock or resource exhaustion.

A Helm upgrade operation failed, leaving the release in a failed state. The application may be partially updated.

A Helm chart installation failed, preventing the application from being deployed to the cluster.

Network policy errors occur when Calico policies are not enforced or configured incorrectly. Fix by verifying policy syntax, enabling enforcement mode, and checking for conflicting rules.

You are trying to upgrade a Helm release, but no previous deployed version exists to upgrade from.

This error occurs when the kubelet garbage collection of container images fails, typically due to disk space or permission issues.

Helm prevents reusing a release name that is still being tracked, even if the resources are deleted.

Helm cannot locate the chart you are trying to install. This is usually because the chart repository is not configured or the chart name is incorrect.

A Kubernetes crd version not served error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes yaml indentation error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes immutable field error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

Service account tokens in Kubernetes expire after a default period (1 hour for most tokens), causing authentication failures and pod communication breakdowns. When a token expires, the API server rejects requests with "invalid bearer token" errors. Fix by refreshing tokens, rotating service accounts, or using projected volumes for automatic token refresh.

Helm install/upgrade blocked. Previous helm command hung or crashed leaving a lock.

This error occurs when the CNI (Container Network Interface) plugin is not installed or configured. Fix it by installing a CNI plugin like Calico, Flannel, or Cilium and ensuring system prerequisites like IP forwarding are enabled.

The Kubernetes API server is down or unreachable, blocking all kubectl operations and cluster management. Causes include API server pod crashes, etcd backing store failures, network connectivity problems, or node resource exhaustion. Fix by checking API server logs, validating cluster networking, verifying etcd health, and restarting the control plane if needed.

In Kubernetes StatefulSets with OrderedReady pod management policy, pods are created sequentially and each pod must reach Ready state before the next one is scheduled. The "waiting for ordinal not yet ready" condition occurs when a pod cannot achieve Ready state, blocking subsequent pods from starting.

ArgoCD fails to generate application manifests due to missing dependencies, timeout issues, invalid configurations, or plugin failures. The error is cached to prevent repeated failures. Fix by checking Helm chart dependencies, validating file paths, clearing the cache, and reviewing repo-server logs. Manifest generation must complete within the 90-second default timeout.

ArgoCD sync operations hang or fail when resource hooks (PreSync, PostSync, Sync, SyncFail) encounter errors, timeouts, or resource conflicts. Causes include Jobs getting deleted before completion, immutable field errors, hook timeout mismatches, or unfinished hook resources. Fix by adjusting ttlSecondsAfterFinished, using proper delete policies, implementing health checks, and debugging hook resource status.

This error occurs when an Ingress resource references a TLS secret that doesn't exist or is misconfigured. Fix it by creating the TLS secret in the correct namespace with proper certificate format, or configure cert-manager for automatic certificate management.

Helm template rendering fails due to syntax errors, missing variables, or invalid YAML. This prevents chart deployment. Debug by testing templates locally, checking values files, and verifying Helm syntax.

ArgoCD cannot locate an Application resource because the YAML is in the wrong namespace, the manifest syntax is invalid, or the Application CRD hasn't been installed. Fix by ensuring the Application is created in the argocd namespace (or configured multi-namespace mode), validating the manifest structure, and verifying ArgoCD is fully deployed.

Volume mount failures prevent pods from accessing storage. This occurs when persistent volumes are unavailable, mount permissions are wrong, or storage backends fail. Pods remain Pending until the issue is resolved.

GCP load balancer health checks fail when there is no network route between load balancer and backend services. Pods become unreachable due to firewall rules, misconfigured routes, or Service endpoint configuration issues.

This error occurs when the proxy or ingress controller cannot connect to the upstream service. Fix it by verifying the application listens on 0.0.0.0, checking service selectors match pod labels, and ensuring pods are healthy and ready.

This RBAC error occurs when a user lacks permission to access a resource. Fix it by creating a Role or ClusterRole with required permissions and binding it to the user with RoleBinding or ClusterRoleBinding.

This error occurs when creating resources that would exceed namespace ResourceQuota limits. Fix it by reducing resource requests, deleting unused resources, or requesting a quota increase from your cluster administrator.

CoreDNS detected a DNS query loop, usually caused by misconfigured forwarders or upstreams. This causes DNS to fail. Disable loop detection, fix forwarder configuration, or review Corefile settings.

Pod emptyDir volume exceeds sizeLimit. Fix by increasing limit, reducing data written, or using persistent volume.

Workload Identity fails when service account bindings are incomplete, KSA annotations are missing, or IAM permissions are misconfigured. Pods cannot access Google Cloud APIs.

Pod scheduling fails when requiredDuringSchedulingIgnoredDuringExecution affinity rules cannot be satisfied. No nodes match the required labels, node resources, or topology constraints.

Headless Service (clusterIP: None) cannot resolve because no pods match the Service selector. DNS returns no A records, stateful applications cannot discover members.

Invalid label values violate Kubernetes naming conventions, preventing resource creation or updates. Labels must follow specific rules for characters, length, and format.

Leader election failures prevent controllers from achieving high availability. When multiple replicas of a controller (operator, webhook, scheduler) cannot elect a leader, none may process events, disrupting cluster operations.

The kubelet requires a CRI-compatible container runtime (containerd, CRI-O, Docker). This error occurs when the runtime is not installed, not running, or disabled. Fix by installing/starting the runtime or enabling the CRI plugin.

DaemonSet pods fail readiness checks due to liveness/readiness probe misconfiguration, application startup delays, or resource constraints. Fix by adjusting probe parameters, increasing initialDelaySeconds, or fixing the underlying application issue.

LimitRange policies enforce minimum and maximum resource requests/limits per pod or container. Exceeding these limits prevents pod creation and violates namespace policy.

IP pool exhaustion occurs when all available IP addresses in the Calico IP pool are allocated. Resolve by expanding the pool CIDR, reclaiming unused IPs, or monitoring IP usage.

LoadBalancer services stuck in "pending" state cannot assign external IPs. This blocks external traffic and prevents service exposure. Usually caused by cloud provider delays, quota issues, or controller problems.

ExcludedResourceWarning appears when ArgoCD encounters resources excluded in global settings. Configure resource inclusions/exclusions properly or override exclusions per-application using sync options.

Error when imagePullPolicy Never but image not cached

Error when Ingress references missing ingressClass

Error when Ingress TLS secret missing

Error when no storage available for PVC

Error when manifest specifies unsupported apiVersion

Cilium endpoint not ready errors occur when pods fail to establish network connectivity. Fix by checking node networking, verifying pod IP allocation, and investigating eBPF program issues.

ClusterMesh errors occur when Cilium cannot establish multi-cluster connectivity. Common causes include certificate mismatches, missing configuration, and API server connectivity issues.

Felix is Calico's policy engine. "Felix not ready" errors indicate liveness probe failures due to timeouts or dataplane issues. Fix by reviewing logs, adjusting probe timings, and ensuring dataplane health.

ArgoCD shows resources as out of sync when the cluster state drifts from the Git repository. This occurs due to auto-generated values, mutating webhooks, or resource normalization. Use ignoreDifferences, sync options, or enable auto-healing to resolve drift issues.

Typha synchronization errors occur when calico-node cannot connect to Typha service. Common causes include service discovery failures, TLS certificate issues, and network connectivity problems.

Sync wave errors occur when resources with wave annotations do not apply in the expected order. Fix by properly configuring argocd.argoproj.io/sync-wave annotations and ensuring hooks complete before dependent resources.

cert-manager certificate issuance fails due to ACME validation errors, invalid issuer configuration, or challenge failures. Fix by verifying issuer status, checking DNS/HTTP validation, and reviewing logs.

BGP peer down indicates that Calico node cannot establish BGP sessions with peers. Common causes include firewall blocking port 179, incorrect peer configuration, or network connectivity issues.

Repository authentication fails when ArgoCD cannot connect due to expired credentials, missing SSH keys, or incompatible key algorithms. Fix by verifying credentials, using personal access tokens, and updating SSH key algorithms.

Deployment image pull fails due to invalid image references, missing credentials, network issues, or registry problems. Fix by verifying image name/tag, checking imagePullSecrets, testing network connectivity, and validating registry access.

Certificate not ready errors occur when CertificateSigningRequest approval or signing fails. Fix by verifying CSR status, checking signer configuration, and approving pending requests.

Deployment pods stay in not-ready state due to failing health checks, application crashes, or resource constraints. Fix by debugging pods, adjusting probe settings, fixing application issues, or increasing resources.

Pod replicas don't match the desired count due to pending pods, crashed containers, or scheduling failures. Fix by checking node capacity, debugging pending pods, and fixing application issues.

Nodes run out of disk space, triggering eviction of pods. Fix by cleaning up disk space, configuring proper storage limits, and monitoring disk usage.

DNS service overloaded causing high CPU usage. Fix by scaling DNS pods, tuning cache settings, or switching to CoreDNS.

Container image specified in pod doesn't exist in registry. Fix by verifying image name, checking registry, and using correct image references.

Container runtime socket access denied. Fix by adding kubelet user to docker group, fixing socket permissions, or using rootless Docker.

Dynamic PVC provisioning fails due to missing StorageClass, wrong provisioner, or cloud provider issues. Fix by checking StorageClass, verifying provisioner, and checking cloud credentials.

Egress NetworkPolicy rules block pod outbound traffic. Fix by reviewing policy selectors, adding proper egress rules for DNS and external services.

Service has no ready endpoints because backing pods aren't ready. Fix by checking pod readiness, fixing application health, and verifying endpoint selectors.

EndpointSlice controller can't sync endpoints due to control plane load or permission issues. Fix by checking controller status, RBAC permissions, and control plane health.

EnvoyFilter configuration rejected by Istio control plane due to invalid spec. Fix by validating Envoy configuration, checking Istiod logs, and testing with simple config.

etcd database full with Kubernetes events. Fix by cleaning up old events, increasing quota, or using separate etcd for events.

HorizontalPodAutoscaler fails to scale because the metric it references does not exist or is invalid. Metrics may be missing from metrics-server or custom metrics provider.

DNS resolution fails for hostnames from within pods. CoreDNS pods are not running, DNS queries timeout, or upstream DNS is unreachable.

This error occurs when a job is configured to run more parallel workers than the cluster can accommodate, typically due to resource constraints or node availability limits.

This error occurs when Kubernetes API server rejects a request due to an invalid, expired, or malformed JWT authentication token, affecting API access and service account authentication.

This error occurs when Kubernetes cannot find a specified key, typically in ConfigMaps, Secrets, or certificate/key operations, preventing pod configuration or security setup.

This error occurs when encryption at rest is expected or attempted, but no KMS provider has been configured on the API server, leaving data unencrypted.

This error occurs when the kubelet CPU manager fails to allocate or manage CPUs, typically due to misconfiguration or topology issues.

This error occurs when the kubelet cannot properly manage container cgroups, typically due to incorrect driver configuration or cgroup issues.

This error occurs when the kubelet reaches its file descriptor limit, preventing new connections and pod operations.

The "Eviction Hard Threshold" error occurs when a node reaches critical resource thresholds (memory, disk, or inodes) and the kubelet forcibly evicts pods to free resources. When a hard threshold is breached, pods are immediately terminated without graceful shutdown, potentially causing data loss.

The "Failed PreStop Hook" error occurs when the PreStop lifecycle hook times out or fails during pod termination. PreStop hooks run before SIGTERM to allow graceful shutdown (connection draining, cleanup), but if they fail, the container is force-killed, causing connection loss and potential data corruption.

The "Memory resource exceeded" error occurs when a pod uses more memory than its limit, causing the kernel to OOMKill (out-of-memory kill) the container. This terminates the pod immediately, disrupting services and data processing. Requires investigating memory leaks and adjusting limits appropriately.

A failing liveness probe causes Kubernetes to repeatedly restart the container, creating a CrashLoopBackOff. The liveness probe detects if a container is deadlocked or unresponsive and triggers a restart to recover. A bad probe configuration or application issue causes restart loops.

This admission error occurs when ResourceQuota or LimitRange requires containers to specify resource limits. Fix it by adding explicit limits.cpu and limits.memory to your container spec.

A failing readiness probe prevents a pod from receiving traffic. The readiness probe indicates if a container is ready to serve requests. When it fails, the pod is removed from load balancing but the container keeps running, allowing debugging without service disruption.

A failing startup probe prevents a container from ever becoming ready. The startup probe (introduced in Kubernetes 1.18) checks if an application has finished starting up. If it fails consistently, the container is killed and restarted after failureThreshold failures.

A Flannel backend error occurs when the pod networking plugin fails to set up or maintain the overlay network. Flannel provides cross-node pod communication via VXLAN, UDP, or host-gw backends. Backend failures prevent pods from communicating across nodes, causing total network isolation.

BackoffLimitExceeded occurs when a Kubernetes Job has reached its maximum retry attempts (default 6) and all pods have failed. The Job is marked as Failed and no further retries occur.

A Flux reconciliation failure occurs when the GitOps operator cannot apply manifests from Git to the cluster. Reconciliation failures prevent deployments from updating, leaving the cluster out of sync with Git. Common causes include invalid YAML, missing CRDs, authentication issues, and resource conflicts.

The "Flannel No Subnet Available" error occurs when Flannel cannot allocate a pod network subnet to a node. This prevents pods from being assigned IP addresses, blocking pod scheduling. The error is usually caused by CIDR pool exhaustion or configuration issues.

A friendly name duplicate error occurs when two resources have the same display name in a context where uniqueness is required. This is usually encountered with custom resources (CRs) or when using status fields that expect unique names.

A Kubernetes resource deletion hangs because a finalizer is blocking removal. This occurs when cleanup logic fails, webhooks timeout, or the finalizer controller crashes. Finalizers are safety mechanisms that prevent accidental resource deletion until cleanup is complete.

A filesystem type not available error occurs when a PersistentVolume or PVC tries to use a filesystem type (ext4, XFS, NFS) that isn't supported by the underlying storage or node. Common with external storage like NFS or block storage.

The "Gateway API Not Installed" error occurs when trying to use Gateway API resources (Gateway, HTTPRoute, etc.) without installing the Gateway API CRDs. The Gateway API is a newer alternative to Ingress that requires explicit installation.

A Flux GitRepository or HelmRepository source cannot be reached or authenticated. This prevents Flux from syncing applications. Verify source connectivity, credentials, and repository configuration.

A Kubernetes node is running out of available process IDs (PIDs). This prevents new Pods and processes from starting, causing resource exhaustion.

A StatefulSet or Pod is trying to connect to a headless Service that does not exist or is not properly configured. This breaks DNS-based service discovery.

You are trying to create a Kubernetes namespace that already exists. This typically occurs in automation scripts or CI/CD pipelines that don't account for idempotency.

A Kubernetes namespace cannot be deleted because a finalizer is blocking termination. Finalizers ensure cleanup operations complete before a resource is removed.

The Descheduler fails to evict Pods based on scheduling policies. This occurs when eviction rules conflict with Pod Disruption Budgets, node affinity requirements, or resource constraints. Resolve by reviewing descheduler strategies, PDB settings, and cluster topology.

This error means the Job has failed repeatedly and exhausted all retry attempts specified in backoffLimit. The Job is marked as permanently failed and requires manual intervention.

A Kubernetes vertical pod autoscaler error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes downward api error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes projected volume error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes flux prune failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

This error occurs when a CronJob has missed more than 100 scheduled job runs, typically after cluster downtime or when jobs run longer than the schedule interval. The CronJob controller stops scheduling to prevent cascade failures.

A Kubernetes service account token error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes runtime class not found error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

NodeNotReady indicates a Kubernetes node cannot run workloads due to kubelet issues, container runtime failures, or resource exhaustion. The control plane taints the node and evicts workloads to healthy nodes.

A Kubernetes priority class not found error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes pod disruption budget error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

NetworkUnavailable indicates the node's CNI is not properly configured. The scheduler prevents new pods from being scheduled on that node because pod networking cannot be established.

A Kubernetes topology spread constraint error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes ephemeral container error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes sidecar container failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

MemoryPressure indicates a node is running critically low on available memory. The kubelet responds by tainting the node, stopping new pod scheduling, and evicting lower-priority pods to reclaim memory.

A Kubernetes knative ingress not ready error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes knative autoscaler error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes knative revision failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes knative service not ready error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes crossplane managed resource error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes crossplane claim not ready error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes crossplane composition error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes crossplane provider error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes velero storage location error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes velero snapshot error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes velero restore failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes velero backup failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes sops decrypt error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes sealed secrets decrypt failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes vault secret not found error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes vault auth failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes external secrets provider error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes external secrets sync failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes linkerd multicluster error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes linkerd viz error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes linkerd tap denied error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes linkerd identity not ready error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes linkerd proxy injection failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes run as root not allowed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes host network not allowed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes host path not allowed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes privileged not allowed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes selinux context error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes seccomp profile error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes kyverno policy violation error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes opa gatekeeper denied error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes psa violation error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes psp denied error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes sandbox create failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes runc error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes runtime network not ready error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes crio not running error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes containerd shim error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes containerd not running error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes signal sigpipe error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes signal sigfpe error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes signal sigbus error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes signal sigabrt error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes exit code 255 error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes exit code 139 error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes exit code 125 error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes kustomize name prefix error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes kustomize base not found error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes kustomize transformer error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes kustomize generator error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes kustomize patch failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes kustomize resource not found error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes kustomize build failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes vector sink error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes promtail target error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes loki query timeout error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes loki ingestion error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes elasticsearch disk watermark error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes elasticsearch cluster red error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes fluentbit backpressure error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes fluentbit parser error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes fluentd output error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes fluentd buffer overflow error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes metrics server not available error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes kube state metrics error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes grafana dashboard error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes grafana datasource error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes prometheusrule error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes prometheus remote write failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes prometheus query timeout error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes prometheus oom error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes prometheus tsdb error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes prometheus podmonitor not found error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes prometheus servicemonitor not found error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes prometheus scrape failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes multus network attachment error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes weave peer connection failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes flannel subnet allocation failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes cilium identity allocation failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes flux drift detected error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

This error occurs when a PersistentVolumeClaim (PVC) cannot find a matching PersistentVolume (PV) to bind to. Common causes include mismatched access modes, storage class issues, or no available volumes. The fix involves ensuring your PVC and PV specifications align correctly.

A Kubernetes flux dependency not ready error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes flux health check failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes flux helm chart pull failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes flux git clone failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes flux helmrelease failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes flux kustomization failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes gke gcs fuse error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes gke anthos service mesh error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes gke config connector error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes gke binary authorization denied error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes gke vpc native error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes gke private cluster error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes gke autopilot resource error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes gke node pool error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes gke service account not found error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes gke workload identity failed error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes eks cluster autoscaler error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes eks fargate profile error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

A Kubernetes eks alb controller error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

This error occurs when the container registry cannot find the manifest for the requested image tag. Fix it by verifying the image name and tag exist in the registry, checking for typos, and ensuring proper authentication.

This error occurs when you exceed Docker Hub's rate limits for image pulls. Fix it by authenticating to increase limits, using registry mirrors, or upgrading to a Docker paid subscription.

A Kubernetes eks ebs csi driver error error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

This error occurs when network connectivity fails between pods, services, or external endpoints. Fix it by verifying IP forwarding settings, checking DNS resolution, reviewing network policies, and ensuring CNI plugins are functioning correctly.

A pod references a Secret that doesn't exist or is in a different namespace. Secrets are namespace-scoped resources; pods can only reference Secrets in their own namespace. Fix by creating the missing Secret in the correct namespace or using External Secrets Operator for externalized secret management.

A Job that was previously running or scheduled has become unavailable. This occurs when Jobs are deleted, garbage collected due to TTL settings, or removed by parent resources. Resolve by checking Job history, TTL configuration, and cleanup policies.

ImagePullBackOff occurs when Kubernetes cannot pull a container image from a registry. The kubelet retries with exponential backoff while you resolve authentication, network, or image reference issues.

Exit code 137 indicates your container was killed by SIGKILL (signal 9), typically due to OOMKilled when exceeding memory limits. Increase memory limits or optimize application memory usage.

Exit code 130 means the container received SIGINT (Ctrl+C). This is typically intentional user interruption, not an error. Verify if termination was expected or implement signal handling.

Pods stuck in Pending status cannot be scheduled to any node. Check for insufficient resources, unbound PersistentVolumeClaims, node selectors, taints/tolerations, or affinity rules.

Pods stuck in Terminating status have finalizers preventing deletion, unresponsive processes, or node communication issues. Remove finalizers or force delete the pod after investigating the cause.

Preempted pods were evicted to make room for higher-priority pods. Adjust priority classes, add cluster capacity, or review resource requests.

CreateContainerError occurs when the container runtime fails to create the container. Unlike config errors, this indicates runtime failures like duplicate containers, volume issues, or permission problems.

InvalidImageName means the container image reference format is invalid. Remove protocol prefixes, use lowercase names, and ensure proper registry/image/tag format.

Error when no node has enough available memory

This error occurs when a pod references an imagePullSecret that doesn't exist in its namespace. Fix it by creating the secret in the correct namespace and ensuring the name matches the pod specification.

This error occurs when the container image doesn't have a variant for your node's architecture. Fix it by building multi-architecture images with docker buildx or using the --platform flag to specify an available architecture.

This error occurs when NetworkPolicy rules block traffic between pods. Fix it by verifying your CNI supports network policies, checking pod label selectors match, and ensuring both ingress and egress rules allow the required traffic paths.

This error occurs when creating a Service with a NodePort that's already in use by another service. Fix it by letting Kubernetes auto-assign the port, finding an available port, or waiting for recently deleted services to release their ports.

This error occurs when the Ingress controller cannot route traffic to a backend service. Fix it by verifying the service exists, checking label selectors match pods, ensuring correct path configuration, and adding rewrite annotations if needed.

This RBAC error occurs when a pod's ServiceAccount lacks permission to access Kubernetes resources. Fix it by creating a Role with required permissions and binding it to the ServiceAccount.

This error occurs when a container's CPU request is below the namespace LimitRange minimum. Fix it by increasing the CPU request to meet or exceed the minimum constraint defined in the LimitRange.

This admission error occurs when ResourceQuota or LimitRange requires containers to specify resource requests. Fix it by adding explicit requests.cpu and requests.memory to your container spec.

This error occurs when a Kubernetes Deployment fails to reach its desired state within progressDeadlineSeconds (default 10 minutes). Pods may be stuck due to image pull failures, scheduling issues, or resource constraints.

DeadlineExceeded occurs when a Kubernetes Job exceeds the time limit specified by activeDeadlineSeconds. Kubernetes terminates all running Pods and marks the Job as failed.

KubeletNotReady occurs when the kubelet service on a worker node becomes unhealthy or stops communicating with the control plane. This is often caused by container runtime failures, certificate issues, or systemd service problems.

DiskPressure indicates a node is running critically low on available disk space. The kubelet stops scheduling new pods and begins evicting existing pods to reclaim disk space.

The Horizontal Pod Autoscaler cannot retrieve CPU/memory metrics from the metrics-server. This blocks all autoscaling decisions and typically indicates the metrics-server is not installed or not running.

The Horizontal Pod Autoscaler cannot find the target Deployment, ReplicaSet, or StatefulSet specified in scaleTargetRef. This is typically caused by typos, namespace mismatches, or incorrect apiVersion.

A namespace is stuck in Terminating state because finalizers have not been removed by their responsible controllers. This blocks namespace deletion and often indicates crashed operators or stuck resources.

This error occurs when kubectl cannot find any kubeconfig file. The kubeconfig provides cluster connection details, authentication credentials, and context settings required to connect to a Kubernetes cluster.

This error occurs when Kubernetes certificates have expired, preventing TLS connections between kubectl and the API server or between cluster components. Certificate renewal is required to restore cluster access.

This error occurs when an operation references a non-existent etcd cluster member, typically after a node removal, incomplete cluster scaling, or misconfigured member IDs. It requires careful member list reconciliation to resolve.

kubeadm init fails during the preflight validation phase when system prerequisites are not met. This safety check validates container runtime, port availability, swap status, and cgroup configuration before cluster initialization.

The FailedPreStopHook warning occurs when a container's preStop lifecycle hook fails during pod termination. Unlike postStart failures, this doesn't prevent termination—the pod will still be killed.

This scheduling error occurs when a PersistentVolume is bound to a specific zone or node, but the pod cannot be scheduled there due to conflicting constraints.

This scheduling error occurs when all available nodes are marked as unschedulable, typically because they have been cordoned for maintenance or have NoSchedule taints.

This error occurs when a node has reached its maximum pod capacity, preventing new pods from being scheduled. The limit is determined by kubelet configuration and available IP addresses.

The FailedMount error occurs when Kubernetes cannot mount a volume to a pod, often due to missing ConfigMaps/Secrets, NFS permission issues, or volume attachment problems.

A Kubernetes eks subnet not found error occurred. This typically indicates a configuration issue, resource constraint, or system problem. Review the error logs, check resource availability, and verify cluster configuration to resolve.

The Horizontal Pod Autoscaler cannot compute scaling decisions because containers are missing CPU resource requests. HPA calculates utilization as (current_usage / requested_resources), making resource requests mandatory.

The Horizontal Pod Autoscaler cannot calculate the desired number of replicas because it's missing critical input data—either metrics are unavailable or resource requests are not defined on containers.

This error occurs when kubectl cannot locate the specified context in your kubeconfig file. It commonly happens when switching between clusters, after deleting a context, or due to kubeconfig file mismatches.

This error occurs when kubectl cannot properly parse or validate your kubeconfig file due to YAML syntax errors, missing required fields, or corrupted data.

This error occurs when an etcd node attempts to join a cluster but has a different cluster ID stored locally, typically due to data directory conflicts or incorrect initialization. It prevents cluster members from communicating.

Kubernetes requires swap to be completely disabled on all cluster nodes before kubeadm can initialize. This error occurs during preflight checks when swap is detected on the system.

gRPC or HTTP/2 services fail when pods refuse connections on the expected port. Network policies, service configuration, or application setup blocks HTTP/2 traffic.