Kubernetes Vocabulary: 40 Terms You Need When Working with K8s

Kubernetes (often abbreviated as K8s) is the standard platform for deploying and managing containerised applications at scale. Even if you are a developer who rarely touches infrastructure, you will hear this vocabulary in sprint planning, incident calls, and architecture reviews. This guide explains 40 essential K8s terms in plain English.

---

The Basic Building Blocks

Pod

A pod is the smallest deployable unit in Kubernetes. A pod wraps one or more containers that share the same network namespace and storage. In practice, most pods run a single container.

“The pod is in CrashLoopBackOff — check the logs with kubectl logs <pod-name>."
"Don’t deploy containers directly — always use a Deployment to manage your pods.”

Deployment

A Deployment is a higher-level resource that manages a set of identical pods. It handles rolling updates, rollbacks, and ensures the desired number of replicas are always running.

“Scale the Deployment to 5 replicas to handle the increased traffic."
"The rollout is stuck — run kubectl rollout status deployment/<name> to see what’s happening.”

ReplicaSet

A ReplicaSet ensures a specified number of pod replicas are running at any time. Deployments create and manage ReplicaSets automatically — you rarely interact with them directly.

Namespace

A namespace is a virtual cluster within a Kubernetes cluster. Teams use namespaces to isolate their workloads — for example, production, staging, and development namespaces in the same cluster.

“Deploy to the staging namespace first and test it there before promoting to production."
"Check which namespace you’re in — kubectl config get-contexts.”

Service

A Service exposes a set of pods as a stable network endpoint. Pods come and go, but the Service IP and DNS name stay constant. Common types: ClusterIP (internal), NodePort, and LoadBalancer (external).

“The app can’t reach the database — check whether the Service selector matches the pod labels."
"Use a ClusterIP service for internal communication and a LoadBalancer for external traffic.”

Ingress

An Ingress is an API object that manages external HTTP(S) access to Services. It allows you to define routing rules — for example, routing /api to one service and / to another — using a single load balancer.

“Add a new host rule to the Ingress so traffic to api.example.com goes to the API service."
"The Ingress controller handles SSL termination, so the pods only see plain HTTP.”

---

Configuration and Storage

ConfigMap

A ConfigMap stores non-sensitive configuration data as key-value pairs. Pods can consume ConfigMaps as environment variables or mounted files.

“Move the database connection string into a ConfigMap instead of hardcoding it in the Deployment spec.”

Secret

A Secret stores sensitive data such as passwords, tokens, and keys. The data is base64-encoded (not encrypted by default — use encryption at rest for production).

“Store the API key in a Secret and reference it in the pod spec as an environment variable."
"Never commit Secret values to Git — use Sealed Secrets or an external secrets operator.”

PVC (PersistentVolumeClaim)

A PersistentVolumeClaim (PVC) is a request for storage. A pod claims a volume through a PVC, and Kubernetes binds it to a matching PersistentVolume (PV). This is how stateful apps persist data.

“The database pod needs a PVC so its data survives pod restarts.”

StatefulSet

A StatefulSet manages pods that need stable identities and persistent storage — databases, message queues, and similar stateful applications. Unlike Deployments, pods in a StatefulSet have predictable names (pod-0, pod-1).

“Use a StatefulSet for Postgres — it guarantees ordered startup and stable storage per pod.”

DaemonSet

A DaemonSet ensures that one copy of a pod runs on every node (or a subset of nodes). It is used for node-level services like log collectors, monitoring agents, and network plugins.

“The log shipper is deployed as a DaemonSet so every node has an agent.”

---

Scaling and Reliability

HPA (Horizontal Pod Autoscaler)

The HPA automatically scales the number of pod replicas based on observed metrics — CPU usage, memory, or custom metrics. When load drops, it scales back down.

“Configure an HPA to scale the API pods between 2 and 20 replicas based on CPU utilisation."
"The HPA is scaling up but the pods are pending — check if the cluster has enough node capacity.”

Resource Requests and Limits

Requests are the minimum resources (CPU, memory) a pod is guaranteed. Limits are the maximum it can use. Setting both correctly is essential for cluster stability.

“Set appropriate resource requests and limits — a pod without them can starve other workloads."
"The pod was OOMKilled — increase the memory limit or fix the memory leak.”

Liveness Probe

A liveness probe checks whether a container is alive. If it fails repeatedly, Kubernetes restarts the container. Use it to recover from deadlocks or corrupted internal state.

“Add a liveness probe on /healthz so Kubernetes restarts the pod if it becomes unresponsive.”

Readiness Probe

A readiness probe checks whether a container is ready to serve traffic. Kubernetes only sends requests to pods whose readiness probe passes. It is critical for smooth rolling updates.

“The readiness probe is failing because the app takes 30 seconds to warm up. Increase the initialDelaySeconds.”

Pod Disruption Budget (PDB)

A PodDisruptionBudget limits how many pods from a set can be disrupted simultaneously during voluntary disruptions (node maintenance, rolling updates). It protects availability during cluster operations.

“We have a PDB that requires at least 2 replicas to be available at all times.”

---

Access Control

RBAC (Role-Based Access Control)

RBAC controls which users and service accounts can perform which actions on which Kubernetes resources. Key objects: Role, ClusterRole, RoleBinding, ClusterRoleBinding.

“Create a Role that allows read-only access to pods in the production namespace."
"The CI pipeline is failing because the service account doesn’t have permission to create Deployments — check the RBAC rules.”

---

Package Management and Extensibility

Helm

Helm is the Kubernetes package manager. A chart is a package of pre-configured Kubernetes resources. Helm lets you install, upgrade, and manage applications with templated YAML files.

“We deploy the application using a Helm chart. Run helm upgrade --install in the CI pipeline."
"Override the default image tag in the Helm values.yaml for the production environment.”

Operator

An Operator is a Kubernetes extension that uses custom controllers to automate the management of complex stateful applications (databases, message brokers, etc.) using Kubernetes-native APIs.

“We use the Postgres Operator to manage database clusters — it handles failover automatically.”

CRD (Custom Resource Definition)

A CRD lets you define your own resource types in Kubernetes. Operators use CRDs to add custom objects like PostgresCluster or KafkaTopic to the Kubernetes API.

“The operator installs a CRD called DatabaseBackup — you can create backup jobs by creating objects of that type.”

---

Working with kubectl

Common kubectl Commands

kubectl is the command-line tool for interacting with a Kubernetes cluster. Here are the phrases you will hear constantly:

“Run kubectl get pods -n production to see what’s running."
"Describe the pod to see the events: kubectl describe pod <name>."
"Forward the port locally for debugging: kubectl port-forward pod/<name> 8080:8080."
"Check the logs: kubectl logs <pod-name> --tail=100 -f."
"Apply the manifest: kubectl apply -f deployment.yaml.”

Context

A context in kubectl is a combination of a cluster, a user, and a namespace. You switch contexts to work with different clusters.

“Switch to the staging context before running that command — you don’t want to apply it to production.”

---

How to Use This in Conversation

In incident response:

“The pods are being evicted — check the node’s memory usage and look at the resource limits.”

In planning:

“We need a StatefulSet for the cache tier, not a Deployment, because each replica needs its own persistent storage.”

In code review:

“The Deployment has no resource limits set — add them before merging. Without limits, this pod could starve other workloads.”

In onboarding:

“Everything in Kubernetes is declarative — you describe what you want, and the control plane makes it happen.”

Mastering this vocabulary will help you navigate K8s documentation, participate in infrastructure discussions, and contribute to reliability conversations with confidence.