Hire elite Kubernetes Engineers.  Pre-vetted for excellence.

Kubernetes Deployments are used for managing stateless applications, where each replica of a pod is interchangeable and doesn't need to maintain persistent state.

StatefulSets, on the other hand, are used for applications that require stable, unique network identifiers and persistent storage, such as databases. They maintain the identity of each pod, even if they are rescheduled or restarted.

A Deployment would be used for services like web applications where pods can be recreated or moved without disrupting the service, while a StatefulSet is necessary when dealing with applications like databases (e.g., MongoDB, Cassandra) that need stable storage and persistent state across pod restarts.

ClusterIP (default): Exposes the service on an internal IP within the cluster. It is used when the service needs to be accessed only from within the Kubernetes cluster.

NodePort: Exposes the service on a static port across each node's IP, allowing external access to the service. It's useful for simple, external access without a load balancer.

LoadBalancer: Provisions an external load balancer (if supported by the cloud provider) and exposes the service to the outside world with a public IP. Ideal for production workloads needing stable external access.

ExternalName: Maps a service to an external DNS name. It’s used when you want to refer to an external service outside the Kubernetes cluster via a service name.

A Senior Kubernetes Engineer should be able to explain when to use each service type based on requirements like internal vs external access, load balancing, and cloud integration.

In Kubernetes, resource requests specify the amount of CPU/Memory that a pod needs to run, while limits define the maximum amount of resources a pod can use.

When a pod is scheduled, Kubernetes uses the requests to determine if there are enough resources available on a node. If the pod exceeds its limit, Kubernetes will throttle the pod’s resource usage or terminate it (in the case of memory limits) and restart it.

Setting appropriate requests and limits helps to ensure fair resource allocation, prevents resource contention, and avoids issues like memory exhaustion or CPU starvation. It’s essential for ensuring that critical applications have the necessary resources to run without overwhelming the system.

StatefulSets should be used for managing stateful applications, as they maintain a consistent identity and stable storage for each pod.

Use Persistent Volumes (PVs) and Persistent Volume Claims (PVCs) for storing data so that it persists even if the pod is rescheduled or deleted.

Consider using Helm charts for templating and automating the deployment of stateful services (e.g., databases).

Pod disruption budgets can be configured to ensure that a minimum number of replicas are always available, even during maintenance or updates.

For databases that need high availability, Kubernetes can be configured with replication and backup strategies that are critical for stateful applications. This may involve using tools like StatefulSet with ReadWriteMany volumes or managing the application’s replication mechanism (e.g., MySQL replication, etc.).

Implementing liveness and readiness probes to monitor the health of the application and ensure it only serves traffic when fully operational.

Check pod logs: Run kubectl logs to see the logs and check if there are any errors or stack traces that indicate the cause of the crash.

Check pod events: Use kubectl describe pod to look at events and determine if the pod is facing issues like resource exhaustion or permission problems.

Check resource allocation: Ensure that the pod’s resource requests and limits are properly set. If a pod is being killed due to resource limits, adjust the values appropriately.

Inspect readiness and liveness probes: Misconfigured probes can cause the pod to be marked as unhealthy and restarted. Verify that they are correctly set.

Examine application dependencies: Ensure that the application is not failing due to missing environment variables, network issues, or service dependencies.

Use kubectl describe on the pod’s deployment: Look for any issues at the deployment level, such as incorrect image versions or misconfigured environment variables.

A Senior Kubernetes Engineer should demonstrate a systematic approach to troubleshooting, starting from logs and events, moving to resource and configuration checks, and leveraging Kubernetes commands for deeper insight.