Kubernetes Pods | probe and answer

What is a pod in Kubernetes?

• A pod is the smallest deployable unit in Kubernetes. It represents a single instance of a running container (or sometimes multiple containers) in a Kubernetes cluster.
• Pods share the same network namespace and storage volumes. Think of it as a "logical host" for containers.

What are the key characteristics of a pod?

• Shared Network Namespace: All containers within a Pod share the same IP address and port space. They can communicate with each other using localhost.
• Shared Storage Volumes: Pods can mount shared volumes that are accessible to all containers within the Pod.
• Ephemeral: Pods are designed to be ephemeral. They can be terminated and recreated by Kubernetes. This is why you shouldn't rely on Pods for persistent storage.
• Multiple Containers (Sometimes): While monitoring), ambassador containers (for proxying), and adapter containers (for transforming data).
• How do you create a pod?
• You typically create pods using declarative YAML or JSON configuration files. These files define the pod's specifications, including the containers it will run, their images, resource requirements, and other settings.
• You then use kubectl apply -f <pod-definition.yaml> to create the pod in your cluster.

How do you view the logs of a pod?

Use the command kubectl logs <pod-name>.

If the pod has multiple containers, specify the container name:
kubectl logs <pod-name> -c <container-name>. For real-time logs, use kubectl logs -f <pod-name>.

How do you execute a command inside a running pod?

• Use the kubectl exec command: kubectl exec -it <pod-name> -- bash (or sh if bash isn't available).
• The -it flags allocate a pseudo-TTY connected to your terminal and keep stdin open, allowing you to interact with the container. Again, specify the container name with -c <container-name> if needed.

What is the difference between a pod and a container?

• A container is a runtime instance of an image. A pod is a wrapper around one or more containers.
• A pod provides a shared environment (network, storage) for containers.rs. You don't deploy containers directly; you deploy Pods.

Explain the lifecycle of a pod.

A pod's lifecycle includes several phases:

• Pending: The pod has been created, but its containers have not yet been created or started.
• Running: All containers in the pod are running.
• Succeeded: All containers in the pod have terminated successfully.
• Failed: One or more containers in the pod have terminated with a non-zero exit code.
• Unknown: The state of the pod cannot be determined.

What are Init Containers?

• Init Containers are specialized containers that run before the main application containers in a pod start.
• They are used to perform initialization tasks, such as setting up the environment, downloading dependencies, or initializing databases.
• They must be completed successfully before the main containers can start.

What are Liveness and Readiness Probes?

• Liveness Probe: Checks if a container is still running and healthy. If the liveness probe fails, Kubernetes restarts the container.
• Readiness Probe: Checks if a container is ready to serve traffic. If the readiness probe fails, Kubernetes removes the pod from the service's endpoints, so it doesn't receive traffic.

How do you manage pods in a production environment?

• In production, you should never create pods directly. Instead, use higher-level abstractions like deployments, replica sets, stateful sets, or daemon sets. These controllers provide features like:
• Replication: Ensuring a desired number of Pod replicas are running.
• Rolling Updates: Updating pods with minimal downtime.
• Self-healing: Automatically replacing failed pods.

Explain pod affinity and anti-affinity.

These features control how pods are scheduled relative to each other.

• Affinity: Allows you to specify rules for scheduling pods on nodes that have certain labels or with other pods that have certain labels. (e.g., "Schedule this Pod on a Node that has a GPU").
• Anti-affinity: Allows you to specify rules for avoiding scheduling pods on nodes with certain labels or with other pods that have certain labels.
• (e.g., "Don't schedule two instances of this pod on the same node").

What are taints and tolerations?

• Taints are applied to nodes, indicating a restriction or condition that makes the node unsuitable for running certain types of workloads.
• Toleration, on the other hand, is applied to pods, indicating that a pod is willing to tolerate the taint on the node, allowing it to be scheduled on the node.

𝗧𝗮𝗶𝗻𝘁𝘀 𝗮𝗻𝗱 𝘁𝗼𝗹𝗲𝗿𝗮𝘁𝗶𝗼𝗻𝘀 𝗮𝗿𝗲 𝗺𝗮𝗶𝗻𝗹𝘆 𝘂𝘀𝗲𝗱 𝘁𝗼 𝘀𝗲𝘁 𝗿𝗲𝘀𝘁𝗿𝗶𝗰𝘁𝗶𝗼𝗻𝘀 𝗼𝗻 𝘄𝗵𝗮𝘁 𝗣𝗢𝗗𝘀 𝗰𝗮𝗻 𝗯𝗲 𝘀𝗰𝗵𝗲𝗱𝘂𝗹𝗲𝗱 𝗼𝗻 𝗮 𝗻𝗼𝗱𝗲.

How do you limit the resources used by a pod?

You can define resource requests and limits in the pod's specification:

• Requests: The minimum amount of resources (CPU, memory) that a pod requires. Kubernetes uses scheduling requests.
• Limits: The maximum amount of resources that a pod can use. Kubernetes enforces limits to prevent Pods from consuming excessive resources.

*What are Pod Disruption Budgets?
*
Pod Disruption Budgets (PDBs) allow you to specify the minimum number of pods that must be available at any given time, even during voluntary disruptions like updates or node maintenance. This helps ensure high availability for your applications.

How can you debug a pod that is in a CrashLoopBackOff state?

kubectl describe pod <pod-name>: Check the Events section for clues about why the container is crashing.

kubectl logs <pod-name>: Examine the container logs for application errors.

kubectl exec -it <pod-name> -- bash: If possible, try to exec into the container to inspect the environment. If the container crashes too quickly, this might not be possible.

Check Resource Limits: Ensure the pod has sufficient resources.

Check Image: Verify the correct image is being used and can be pulled.

What is a pod in Kubernetes, and why is it considered the smallest deployable unit?

• A pod is a logical group of one or more containers sharing storage, network, and specifications.
• It represents the smallest deployable unit because Kubernetes manages workloads at the pod level.

In a cluster with two nodes, one with pods and the other without, which node will a new pod be scheduled to?

When a new pod is scheduled, Kubernetes considers several factors before deciding which node to place it on.

Key Factors in Scheduling Decision

• Node Affinity & Taints/Tolerations
• Resource Availability (CPU & Memory)
• Node Readiness & Conditions

• Pod Distribution (Binpacking vs. Spreading)

• If both nodes are healthy and have enough resources, Kubernetes will likely schedule the new pod on the empty node to balance the load.

• If the empty node is not ready or has taints preventing scheduling, the pod will be scheduled on the node that already has pods.

More about Kubernetes: The Pod Squad (and How to Manage Them All)