An Introductory Guide to Managing the Kubernetes Pods Lifecycle

A Pod is the smallest unit of a Kubernetes deployed cluster. Pods are imperative entities, and the Kubernetes ecosystem needs them to function. Kubernetes uses a container to package dependencies and resources required to run an application. Kubernetes must track different container states.

Pods are transient; they are short lived and can be created, rebuilt, deleted, and replaced at any time. Pods status represents the lifecycle of how Kubernetes manages running your code for you. This guide provides an introductory overview of managing the Kubernetes Pod lifecycle.

Why Pod Lifecycles Matter

Kubernetes Pods are often managed using higher-level controllers PodTemplate fields, such as Deployments, ReplicaSets, DaemonSets, StatefulSets, or Jobs. They determine how a Pod is created and updated.

Pods are generally used to troubleshoot issues around your application. Thus, understanding Pods and their lifecycle provides snapshots of how to troubleshoot issues while running your application.

How Pods Record Lifecycles

Kubernetes Pods record the states of its status. A Pod's state is recorded at any stage in its lifecycle using a PodStatus API object. It provides information that summarizes the current states of a pod using fields such as phase, conditions, initContainerStatuses, and containerStatuses.

Phase describes the current phase of your Pod's lifecycle. It gives details of which state the Pod is within the clusters. Let's say you've executed the following kubectl command:

kubectl get pods

Kubernetes often returns the current phase of a Pod lifecycle using keywords such as the following:

How to Read Pod Lifecycle Status

To get into further details of your Pod's lifecycle, the PodStatus API object uses detailed commands such as the following:

kubectl describe pod <pod-name>

The following example shows the conditions of a running Pod:

If the Pod has another status, such as CrashLoopBackoff, you would expect the following conditions:

kubectl logs <pod-name>

These commands provide insight into your Pods lifecycle. However, you can integrate the Pod lifecycle with hooks to instruct kubelet to perform various actions before or after specific events in the Pod lifecycle.

Kubernetes Container Lifecycle Hooks

Pod lifecycle hooks trigger events at specific stages in the cluster lifecycle. For instance, if a Pod container is being terminated, you can create a hook script that will let you know the container graceful shutdown before it terminated or a hook script to let you know initContainer is running before the main application container is started.

The lifecycle hooks role is to configure the right handlers to manage your workloads perfectly. For example, a load balancer can still send traffic to a Pod that is already terminated. Lifecycle hooks manage such situations by executing asynchronous tasks that start initializations and the deregistration process of your containers. They verify these tasks have been completed and then proceed to start the Pod container or terminate it. Kubernetes provides Containers with the following lifecycle hooks:

Kubernetes provides the following two approaches to implement these hook handlers:

Using Lifecycle Hooks

These hooks apply only to the container in which they're defined. Let’s create a few Kubernetes manifests to demonstrate how the hooks mechanism works. Below is a simple example of how to execute a basic postStart hook:

apiVersion: v1
kind: Pod
metadata:
  name: test-pod
spec:
  containers:
  - name: testcontainer
    image: nginx
    # lifecycle hook spec
    lifecycle:
      postStart:
      # Your Exec handler
        exec:
          command: ["/bin/sh", "-c", "date", "echo postStart hook executed > /test.log"]

Go ahead and run the kubectl command and deploy Pod to your cluster:

kubectl apply -f you_manifest.yaml

To test your postStart hook, use kubectl to execute a shell that accesses your running Pod container:

kubectl exec --stdin --tty test-pod -- sh

You can now read the contents logged to your test.log file as follows:

# cat /test.log 

postStart hook executed

Since postStart has no errors, the containers will be created successfully:

Kubelet must be able to execute postStart before creating the container. If the exec command is successful, kubelet won’t proceed to other container creating events. Consider the following invalid command:

lifecycle:
  postStart:
    exec:
      command: ["broken command"]

Kubelet won’t be able to execute the postStart hook, and the API won’t be able to successfully create your containers:

In this instance, kubelet has started successfully. However, you have a postStart hook in your lifecycle. If the command this hook executes isn't successful, your containers fail to create and eventually exit with a CrashLoopBackOff status. A perfect use case of postStart would be running a script to set up a database schema/migration or performing health checks before the container starts.

Using a PreStop Lifecycle Hook

The preStop hook executes a command just before the container is terminated. Check the following example that executes the redis-cli shutdown command using a preStop hook.

apiVersion: v1
kind: Pod
metadata:
  name: redis-pod
spec:
  containers:
  - name: redis-container
    image: redis
    ports:
    - containerPort: 6379
    volumeMounts:
    - name: redis-data
      mountPath: /src/redis/data
    lifecycle:
      preStop:
        exec:
          command: ["redis-cli shutdown"]
  volumes:
  - name: redis-data
    emptyDir: {}

To learn how preStop works in this scenario, check the logs of the redis-container container created above:

kubectl logs -f redis-pod -c redis-container

Try to terminate the redis-pod while watching the logs of your container in the above terminal output:

kubectl delete pod/redis-pod

When you delete the above Pod object, your preStop hook is executed before the Pod is terminated. Kubernetes sends a TERM signal to the main process of the Pod to allow any containers to gracefully shut down and terminate any child processes.

Best Practices for Managing the Pod Lifecycle

The Pod lifecycle is an important concept for managing your Kubernetes cluster. The following practices are necessary to ensure Pods runs smoothly:

Conclusion

Pod lifecycle trigger events for managing your workloads. They create practical handling scenarios to understand events of your application's runtime. This guide introduced you to Kubernetes Pods lifecycle and how to use them. I hope you found it helpful!

This post was written by Rose Chege. Rose is a technical writer, a lover of technology, and an upright individual unafraid to get out of her comfort zone and try new programming paradigms. She loves writing code and solving programming problems while sharing her skill using articles.