Kubernetes Rollout commands

Restart Pods in Kubernetes

To restart a pod in Kubernetes, you can either delete the existing pod or use a rolling restart strategy depending on your use case. Here are the commands for both methods:

Delete and recreate the pod: This method involves deleting the existing pod, which will trigger Kubernetes to create a new pod in its place.

Use the kubectl delete command to delete the pod. You need to specify the pod name and its namespace if it's not in the default namespace. For example:
```
 kubectl delete pod <pod-name> -n <namespace>
```
Replace <pod-name> with the name of the pod you want to restart and <namespace> with the namespace it's located in.

After you delete the pod, Kubernetes will automatically create a new one with the same configuration.
Rolling Restart with Deployments: If your application is managed by a Deployment resource in Kubernetes, it's recommended to perform a rolling restart. This ensures that your application remains available during the restart process by replacing pods gradually.

Use the kubectl rollout restart command to initiate a rolling restart of a deployment:
```
 kubectl rollout restart deployment/<deployment-name> -n <namespace>
```
Replace <deployment-name> with the name of your deployment and <namespace> with the appropriate namespace if needed. This command will cause Kubernetes to gradually replace pods, one by one, ensuring minimal disruption.

Using a rolling restart is a best practice when working with applications in Kubernetes, as it minimizes downtime and provides better control over the update process.

Rollout Restart using CronJob

To perform a rolling restart of a Kubernetes Deployment using a CronJob with cron scheduling, you can create a CronJob that runs a script which triggers the rolling restart on a specific schedule. Here's a general outline of how you can achieve this:

Create a Kubernetes CronJob Manifest: Create a Kubernetes manifest for the CronJob. Here's an example YAML manifest:

 apiVersion: batch/v1beta1
 kind: CronJob
 metadata:
   name: rolling-restart-cron
 spec:
   schedule: "0 3 * * *"  # Set your desired cron schedule
   jobTemplate:
     spec:
       template:
         spec:
           containers:
           - name: rolling-restart-container
             image: your-image:your-tag  # Replace with an image that includes your script
             command: ["sh", "-c"]
             args: ["kubectl rollout restart deployment/<deployment-name> -n <namespace>"]
           restartPolicy: OnFailure

In the above manifest, replace:

<deployment-name> with the name of your Deployment.
<namespace> with the appropriate namespace.
Set the schedule field to your desired cron schedule. In this example, it's set to run at 3 AM daily (you can adjust this as needed).

Create the CronJob: Apply the CronJob manifest to create the CronJob in your Kubernetes cluster:
```
 kubectl apply -f your-cronjob-manifest.yaml
```
Ensure the Image Contains kubectl: The image specified in the image field should have kubectl installed, as it's used to trigger the rolling restart.
Script Considerations: The script specified in the args field is a simple shell command to run kubectl rollout restart on the Deployment. You can customize this script further as needed. Ensure that the script is executable within the container.
Test and Monitor: Test the CronJob to ensure it behaves as expected, and monitor the rolling restarts to verify they are performed according to your schedule.

This setup will schedule a rolling restart of your specified Deployment at the specified times according to your cron schedule. Be cautious when scheduling restarts, especially in a production environment, to minimize any potential disruptions.

Rollout update in Kubernetes

In Kubernetes, updating a Deployment involves making changes to the configuration or the image used by your application pods. Kubernetes provides a built-in mechanism for performing rolling updates to ensure minimal disruption to your application during the update process. Here's how to perform a rollout update in Kubernetes:

Assuming you have a Deployment named "my-deployment" and you want to update it:

Update Your Deployment YAML:

First, make the necessary changes to your Deployment's YAML file. You can edit this file directly or create a new one with the desired updates. For example, to change the container image, update the spec.template.spec.containers.image field:

 apiVersion: apps/v1
 kind: Deployment
 metadata:
   name: my-deployment
 spec:
   replicas: 3
   template:
     spec:
       containers:
       - name: my-app
         image: new-image:tag  # Update to the new image

Apply the Updated Deployment:

Apply the updated Deployment YAML to your cluster using the kubectl apply command:
```
 kubectl apply -f updated-deployment.yaml
```
Monitor the Update:

Kubernetes will automatically initiate a rolling update of your Deployment. To monitor the progress of the update, you can use the following command:
```
 kubectl rollout status deployment/my-deployment
```
This command will display the status of the rolling update, including the number of updated, available, and desired replicas.
Rollback (if necessary):

If the update encounters issues or you need to revert to the previous version, you can perform a rollback using the kubectl rollout undo command. For example:
```
 kubectl rollout undo deployment/my-deployment
```
This command will revert the Deployment to the previous version.

By following these steps, you can safely and efficiently update your Deployments in Kubernetes using the built-in rolling update mechanism. This process ensures that your application remains available and minimizes downtime during the update process.

Rollout Update using CronJob

To create a CronJob for rolling out an update of a Deployment running in Kubernetes, you can use a CronJob to trigger a rolling restart of the Deployment at specified intervals. This is especially useful for automating the process of updating your application with the latest container image or configuration. Here's an example:

Create a CronJob Manifest: Create a Kubernetes CronJob manifest that includes the rolling restart of your Deployment. Here's an example YAML:

 apiVersion: batch/v1beta1
 kind: CronJob
 metadata:
   name: deployment-rolling-restart
 spec:
   schedule: "0 2 * * *"  # Set your desired cron schedule
   jobTemplate:
     spec:
       template:
         spec:
           containers:
           - name: kubectl-container
             image: kubectl:latest  # Use an image with kubectl installed
             command: ["kubectl"]
             args: ["rollout", "restart", "deployment/<deployment-name>", "-n", "<namespace>"]
           restartPolicy: OnFailure

In the CronJob manifest:

Set the schedule field to specify when you want the rolling restart to occur (in this example, it's set to run at 2 AM daily).
Replace <deployment-name> with the name of the Deployment you want to update.
Replace <namespace> with the namespace where your Deployment is located.

Apply the CronJob: Apply the CronJob manifest to your Kubernetes cluster:
```
 kubectl apply -f your-cronjob-manifest.yaml
```
The CronJob will execute the kubectl rollout restart command according to the schedule you define, triggering a rolling restart of your specified Deployment. This is a convenient way to automate routine updates while minimizing downtime.

Make sure to adapt the script to your specific deployment and namespace, and be cautious when scheduling restarts, especially in a production environment, to minimize disruptions.