How to Automatically Restart Pods in Kubernetes on a Schedule

Kubernetes, the open-source container orchestration platform, provides a robust environment for deploying, managing, and scaling containerized applications. In some scenarios, you might want to automatically restart pods at scheduled intervals to ensure the health, performance and response of your applications. In this guide, we’ll explore an easy and efficient way to achieve this using Kubernetes CronJobs.

Why Automatically Restart Pods?

Regularly restarting pods can be beneficial for various reasons:

1. Memory Leak Mitigation: Restarting pods helps in releasing accumulated memory and resources, mitigating the impact of potential memory leaks.
2. Application Cleanup: Certain applications may benefit from periodic restarts to clean up internal state and resources.
3. Configuration Updates: Applying changes to configurations or environment variables might require a pod restart to take effect.

Now, let’s dive into how you can schedule pod restarts effortlessly.

Step 1: Create a Kubernetes CronJob

CronJobs in Kubernetes allows you to run Jobs on a repeating schedule. We’ll leverage this feature to automatically restart pods. Let’s create a simple CronJob YAML file:

apiVersion: batch/v1beta1
kind: CronJob
metadata:
  name: pod-restarter
spec:
  schedule: "0 0 * * *"  # Run the job every day at midnight
  jobTemplate:
    spec:
      template:
        spec:
          restartPolicy: OnFailure
          containers:
          - name: pod-restarter-container
            image: your-docker-image:latest
            # Add any other container specifications here

• schedule: This field defines the cron schedule. In this example, the job runs every day at midnight.
• restartPolicy: This is set to “OnFailure” to ensure the pod is restarted in case of any failures.
• containers: Define the container specifications, including the image that contains the logic for restarting pods.

Step 2: Implement Pod Restart Logic

Inside the container specified in your CronJob, you need to include the logic to restart pods. One way to do this is by using kubectl commands. Create a simple script, for example, restart-pods.sh:

#!/bin/sh
kubectl get pods --selector=your-app-label -o name | xargs kubectl delete

Replace your-app-label with the label that identifies the pods you want to restart.

Step 3: Apply CronJob and Pod Restart Logic

Apply the CronJob to your Kubernetes cluster:

kubectl apply -f your-cronjob.yaml

Apply RBAC (Role-Based Access Control) configurations if necessary, i.e. ServiceAccount, Role, RoleBinding:

# Your RBAC configurations go here
...

Apply RBAC configurations:

kubectl apply -f your-rbac-config.yaml

Integration with Jenkins Pipeline

If your Kubernetes setup is integrated with Jenkins, you might want to trigger pod restarts directly from your Jenkins pipeline. Modify your Jenkins pipeline script (Jenkinsfile) to include the logic for triggering the CronJob:

pipeline {
    agent any

    stages {
        stage('Trigger Kubernetes CronJob') {
            steps {
                script {
                    sh 'kubectl create job --from=cronjob/pod-restarter manual-pod-restart'
                }
            }
        }
        // Other stages...
    }
}

This pipeline stage uses kubectl create job to manually trigger the CronJob named pod-restarter whenever it’s needed. You can adjust the script according to your specific environment.

Conclusion

Automatically restarting pods in Kubernetes on a schedule is a straightforward process using CronJobs. Whether you opt for a standalone CronJob or integrate it into your Jenkins pipeline, this approach ensures the health and reliability of your containerized applications. Experiment with different schedules based on your application’s needs and monitor the impact of automatic pod restarts on your overall system health.

Happy scheduling!