Kubernetes Interview Questions and Answers (2025) | JaganInfo

Kubernetes is an open-source container orchestration platform designed to automate deployment, scaling, and management of containerized applications.

Key components include the Master Node (API Server, Controller Manager, Scheduler, etcd), and Worker Nodes with kubelet, kube-proxy, and container runtime.

A Pod is the smallest deployable unit in Kubernetes, consisting of one or more containers sharing networking and storage resources.

A Node is a worker machine in Kubernetes cluster that runs pods and is managed by the Master Node.

A Kubernetes Cluster is a set of nodes (master and workers) that run containerized applications managed by Kubernetes.

etcd is a distributed key-value store that stores Kubernetes’ cluster configuration, state, and metadata.

ReplicaSet ensures a specified number of pod replicas are running at any time to provide high availability.

Deployment manages ReplicaSets and provides declarative updates for Pods and ReplicaSets to enable rolling updates and rollbacks.

A Service defines a logical set of pods and a policy to access them, providing load balancing and stable network access.

kubelet is an agent running on each node that communicates with the Master and manages the lifecycle of containers on that node.

Kubernetes uses a flat networking model with overlay or underlay networks. Each Pod gets its own IP, and services use ClusterIP or NodePort for access with kube-proxy managing routing.

Namespaces provide a mechanism to isolate groups of resources within a cluster and are used for multi-tenancy and resource separation.

StatefulSet manages stateful applications by providing unique network IDs and persistent storage, maintaining the identity of Pods across rescheduling.

DaemonSet ensures that a copy of a pod runs on all or selected nodes to deploy cluster-wide agents like monitoring or logging.

Using Horizontal Pod Autoscaler which automatically scales the number of pod replicas based on observed CPU utilization or custom metrics.

Persistent Volumes are cluster-wide storage resources provisioned by admins; Persistent Volume Claims are requests for storage by users used by pods.

kube-proxy runs on each node and maintains network rules to allow network communication to Pods from inside or outside the cluster.

ConfigMap is a Kubernetes API object used to store non-confidential configuration data in key-value pairs to decouple configs from container images.

Secret stores sensitive data like passwords, tokens, or keys, which can be mounted as files or environment variables in pods.

Rolling updates replace pods of an application incrementally without downtime, updating pod templates managed by Deployments.

Labels are key/value pairs attached to objects; Selectors query objects based on labels to group and filter resources.

Admission Controllers are plugins that intercept requests to the API server to validate and mutate resources during creation or update.

Kubernetes monitors pod and node health and restarts, replaces, or reschedules pods if they fail or nodes become unhealthy.

Network Policies allow fine-grained control over network traffic between pods, namespaces, and external endpoints in the cluster.

kube-scheduler watches for unscheduled pods and assigns them to nodes based on resource availability and scheduling policies.

Use RBAC for access control, Network Policies, Secrets management, audit logging, and regularly update Kubernetes components.

Check pod logs, events, describe the pod, verify container images, and network/connectivity.

Helm is a package manager for Kubernetes that simplifies deployment and management of complex applications using charts.

Job creates one or more pods that run to completion; CronJob creates Jobs on a schedule similar to cron in Linux.

Deployment manages stateless replicas and scales; DaemonSet runs one pod per node for cluster-wide services.

etcd is a distributed, reliable key-value store used to store all Kubernetes cluster data, configuration, and state, providing consistent and fault-tolerant storage.

The Control Plane consists of the API Server, Scheduler, Controller Manager, and etcd. It manages the overall cluster state and makes scheduling decisions.

Role-Based Access Control (RBAC) restricts access to Kubernetes resources based on user roles and permissions, securing the cluster.

Cluster Autoscaler automatically adjusts the size of the Kubernetes cluster based on resource demands, scaling up nodes when needed and scaling down idle nodes.

CRDs allow extension of Kubernetes with custom resource types; Operators are software extensions that use CRDs to manage applications and automate tasks.

A Service exposes pods internally or externally; Ingress manages external HTTP/HTTPS access, routing requests to Services with rules and load balancing.

By enabling encryption at rest, restricting RBAC permissions, and integrating with external secret management tools.

Multi-cluster networking involves federation, service mesh, or VPN-based connectivity to enable communication across clusters.

PDBs specify the minimum number of replicas that must be available during voluntary disruptions to maintain application availability.

Kubernetes uses liveness, readiness, and startup probes to check container state and decide restarting or routing traffic.

Operators automate management of complex applications on Kubernetes, extending Kubernetes APIs to handle lifecycle management.

Use tools like Prometheus for metrics, Fluentd/Elasticsearch for logs, and Grafana for dashboards to monitor cluster and app health.

Admission Controllers intercept API requests and can enforce policies, mutate objects, and validate resource creation and updates.

RBAC, Network Policies, Pod Security Policies, Secrets management, Audit Logging, and TLS for secure communication.

HPA adjusts the number of pod replicas automatically based on observed CPU utilization or custom metrics.

Service Mesh provides fine-grained control over service-to-service communication, with features like traffic control, retries, security, and observability.

Regular backup of etcd data ensures cluster recovery in disasters. Recovery involves restoring etcd snapshots to restore cluster state.

Kubernetes uses Persistent Volumes, Persistent Volume Claims, Storage Classes, and dynamic provisioning to manage storage abstractly.

Webhooks are HTTP callbacks invoked by the Kubernetes API server to the Admission Controllers or external services to extend cluster behavior.

Upgrading involves sequentially upgrading master and worker nodes using kubeadm or managed services ensuring zero downtime with compatibility checks.