Skip to main content

[SOLVED] Kubernetes how to make Deployment to update image - kubernetes

[SOLVED] How to Update Image in Kubernetes Deployments: A Simple Guide

In this chapter, we look at important ways to update container images in Kubernetes Deployments. This is key for keeping our applications running well in the cloud. Knowing how to update images helps us use the latest features, security fixes, and better performance. This guide shows different ways to update the image in Kubernetes Deployments easily. We will cover manual updates and automation techniques.

Here are the solutions we will talk about:

  • Solution 1 - Update Image Tag in Deployment Manifest
  • Solution 2 - Use kubectl set image Command
  • Solution 3 - Rollout Restart for Image Update
  • Solution 4 - Automate Image Update with CI/CD Pipeline
  • Solution 5 - Use ImagePullPolicy for Latest Images
  • Solution 6 - Verify Deployment Status After Update

When we learn these methods, we can handle image updates better in our Kubernetes environment. For more tips on related Kubernetes topics, you can check our articles about why container memory usage is high and how to pull environment variables. Let’s start!

Solution 1 - Update Image Tag in Deployment Manifest

To change the image in a Kubernetes Deployment, we can do it easily by editing the Deployment manifest. This means we will change the image tag in the YAML file that shows our Deployment.

Here is how we can do it:

  1. Edit the Deployment YAML: First, we find the Deployment manifest file (like deployment.yaml). Then, we look for the spec.template.spec.containers part. Here, we will write the new image tag.

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: my-app
    spec:
      replicas: 3
      selector:
        matchLabels:
          app: my-app
      template:
        metadata:
          labels:
            app: my-app
        spec:
          containers:
            - name: my-container
              image: my-image:latest # Change 'latest' to your new image tag
              ports:
                - containerPort: 80
  2. Apply the Changes: After we update the image tag, we run this command to apply the changes to our Kubernetes cluster:

    kubectl apply -f deployment.yaml
  3. Verify the Update: We can check if the Deployment has updated the image by using:

    kubectl rollout status deployment/my-app

    This command will show us the status of the rollout. It will tell us if the new image is being used.

Changing the image tag in the Deployment manifest is a common way to manage app versions in Kubernetes. For more info on managing Kubernetes manifests, we can look at this guide on Kubernetes manifests.

If we have problems with the updated image, we should check the deployment logs. We can see the logs by using:

kubectl logs deployment/my-app

This method makes sure our app runs the right version of the image. It is a good choice for version control in Kubernetes.

Solution 2 - Use kubectl set image Command

One of the easiest ways to change the image of a Kubernetes Deployment is to use the kubectl set image command. This command let us set the new image for our containers right from the command line. It helps us to update quickly without changing the Deployment manifest file.

Steps to Update the Image Using kubectl set image

  1. Identify Your Deployment: First, we need to find the name of the Deployment we want to update. We can list all Deployments in the current namespace with this command:

    kubectl get deployments
  2. Use the kubectl set image Command: Now we run the kubectl set image command to change the image. The command looks like this:

    kubectl set image deployment/<deployment-name> <container-name>=<new-image>:<tag>
    • Change <deployment-name> with the name of your Deployment.
    • Change <container-name> with the name of the container in the Deployment.
    • Change <new-image> with the new image name.
    • Change <tag> with the image tag you want (for example, latest or v1.0).

    Example:

    If we have a Deployment called my-app with a container named my-container, and we want to update it to use the image my-app-image:v2.0, the command will be:

    kubectl set image deployment/my-app my-container=my-app-image:v2.0
  3. Verify the Update: After we run the command, we can check if the update worked by looking at the rollout status of the Deployment:

    kubectl rollout status deployment/my-app

    We can also describe the Deployment to see the image that is being used now:

    kubectl describe deployment my-app
  4. Rollback if Necessary: If we see problems after the update and want to go back to the old image, we can roll back the Deployment:

    kubectl rollout undo deployment/my-app

Using the kubectl set image command is a good way to manage image updates in Kubernetes Deployments. If we want to do more complex image management and updates, we should explore CI/CD pipelines or automating image updates in our development workflow.

Solution 3 - Rollout Restart for Image Update

To update the image of a Kubernetes Deployment without changing the Deployment manifest directly, we can use the kubectl rollout restart command. This command starts a rolling restart of the pods. It makes them pull the latest image based on the image tag we set.

Steps to Perform a Rollout Restart

  1. Identify the Deployment: First, we need to know the name of the Deployment we want to update. We can list all Deployments in our namespace by using:

    kubectl get deployments
  2. Perform the Rollout Restart: We can run this command to restart the Deployment:

    kubectl rollout restart deployment <deployment-name>

    Here, we replace <deployment-name> with the name of our Deployment.

  3. Verify the Rollout Status: After we start the rollout restart, we can check the status of the Deployment with:

    kubectl rollout status deployment <deployment-name>

    This command shows if the rollout is done or if there are any problems.

Example

Let’s say we have a Deployment named my-app. We can update its pods to use the latest image like this:

kubectl rollout restart deployment my-app
kubectl rollout status deployment my-app

Considerations

  • Image Tagging: We should make sure that the image tag is set correctly in our Deployment manifest. If we use a specific tag like my-app:v1.0, the pods will only pull that image unless we change the tag.

  • ImagePullPolicy: If we want to always pull the latest image, we should set the imagePullPolicy to Always. This way, Kubernetes pulls the latest image every time a pod starts. We can set it in our Deployment manifest like this:

    spec:
      containers:
        - name: my-app
          image: my-app:latest
          imagePullPolicy: Always

Using the kubectl rollout restart command is a simple way to update our Kubernetes Deployment’s image without changing the manifest directly. For more advanced ways to deploy and manage images, we can look for more resources on Kubernetes image updates.

Solution 4 - Automate Image Update with CI/CD Pipeline

We can make the image update process in Kubernetes easier by using a CI/CD pipeline. This will help us deploy faster and need less manual work. We can use tools like Jenkins, GitLab CI, GitHub Actions, or CircleCI to automate building and deploying container images. This happens whenever we change the source code.

Steps to Automate Image Updates

  1. Set Up Source Code Repository: First, we should have our application code on a version control system like GitHub, GitLab, or Bitbucket.

  2. Create a CI/CD Pipeline:

    • We need to define a pipeline configuration file. This could be .gitlab-ci.yml for GitLab CI or .github/workflows/main.yml for GitHub Actions. This file will have the steps to build the image, push it to a container registry, and update the Kubernetes deployment.
  3. Build and Push the Docker Image:

    • In the CI/CD configuration file, we add a stage to build the Docker image and push it to a container registry. Here is an example using GitHub Actions:
    name: CI/CD Pipeline
    
    on:
      push:
        branches:
          - main
    
    jobs:
      build:
        runs-on: ubuntu-latest
        steps:
          - name: Checkout Code
            uses: actions/checkout@v2
    
          - name: Log in to Docker Hub
            run: echo "${{ secrets.DOCKER_PASSWORD }}" | docker login -u "${{ secrets.DOCKER_USERNAME }}" --password-stdin
    
          - name: Build Docker Image
            run: |
              docker build -t yourusername/yourapp:${{ github.sha }} .
    
          - name: Push Docker Image
            run: |
              docker push yourusername/yourapp:${{ github.sha }}
  4. Update Kubernetes Deployment:

    • After we push the image, we can update the Kubernetes deployment using the kubectl set image command in the CI/CD pipeline. We can add this step to our pipeline configuration:
    - name: Update Kubernetes Deployment
      run: |
        kubectl set image deployment/your-deployment your-container=yourusername/yourapp:${{ github.sha }} --kubeconfig ${{ secrets.KUBECONFIG }}
  5. Triggering the Pipeline:

    • The pipeline will start automatically every time we push to the main branch. This way, our Kubernetes deployment will always use the latest version of our application.

Benefits of CI/CD Automation

  • Consistency: This makes sure we deploy the same image version each time. It reduces mistakes.
  • Speed: It automates deployment. This helps us release features faster.
  • Rollback Capability: Many CI/CD systems can automatically roll back if something goes wrong during deployment.

By automating image updates with a CI/CD pipeline, we can make our workflow for Kubernetes deployments smoother. For more information on managing containers, we can check this article on why container memory usage is crucial and how to pull environment variables.

Solution 5 - Use ImagePullPolicy for Latest Images

We want to make sure that our Kubernetes Deployment always uses the latest image. We can do this by setting the imagePullPolicy in our container specification. This setting controls when Kubernetes pulls the image from the container registry. It is helpful if we tag our images with latest or any other tag that can change.

Setting ImagePullPolicy

The imagePullPolicy can have three values:

  1. Always: Kubernetes pulls the image from the registry every time a Pod is made.
  2. IfNotPresent: Kubernetes pulls the image only if it is not already on the node.
  3. Never: Kubernetes does not pull the image. It expects the image to already be on the node.

For getting the latest image, we should set imagePullPolicy to Always. This is important when we use the latest tag for our image. Here is how we can do it in our Deployment manifest:

Example Deployment Manifest

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
        - name: my-container
          image: my-docker-repo/my-app:latest
          imagePullPolicy: Always
          ports:
            - containerPort: 80

Notes on ImagePullPolicy

  • When we use imagePullPolicy: Always, Kubernetes will pull the latest version of our image from the registry when a Pod starts. This is very useful in development or staging where we update images often.

  • If we use a tagged image like my-app:v1.0, the imagePullPolicy will be IfNotPresent by default. This means Kubernetes will not pull the image if it is already on the node. If we want to make sure the image updates, we need to change it to Always.

  • We should be careful with Always in production. It can make startup times longer and cause downtime if the image is not available in the registry.

By setting the imagePullPolicy right, we can manage how Kubernetes updates images for our deployments. For more details about container management, we can check out this guide on container memory usage.

Solution 6 - Verify Deployment Status After Update

After we update the image in our Kubernetes Deployment, we need to check if the Deployment has rolled out the new version. This helps us make sure that our application is using the right image and working well. We can use the kubectl command-line tool for this.

Here are the steps to check the status of our Deployment:

  1. Get Deployment Status: We can use this command to see the current status of our Deployment:

    kubectl rollout status deployment/<your-deployment-name>

    We should replace <your-deployment-name> with the name of our Deployment. This command will give us a clear message about if the rollout was successful or if there are problems.

  2. Check Pods Status: To make sure the Pods are running with the new image, we can list the Pods linked to our Deployment:

    kubectl get pods -l app=<your-app-label>

    We need to replace <your-app-label> with the right label for our application. The output will show us the status of each Pod. We should look at the STATUS column, which should say Running.

  3. Describe the Deployment: If we want more details about the Deployment or any problems, we can use the describe command:

    kubectl describe deployment <your-deployment-name>

    This command will show us more about the current state of the Deployment. It includes conditions, events, and any errors that happened during the rollout.

  4. View Pod Logs: If we have issues with the updated Pods, checking the logs can help us understand better. We can use this command to see logs from a specific Pod:

    kubectl logs <pod-name>

    We should replace <pod-name> with the name of the Pod we want to check. This can help us find if there are any problems with the application after the image update.

  5. Rollback if Necessary: If we find that the new image is causing trouble, we can go back to the old version using:

    kubectl rollout undo deployment/<your-deployment-name>

This command will bring our Deployment back to the last stable state. This helps reduce downtime.

By following these steps, we can check the Deployment status after updating the image in our Kubernetes cluster. For more help with Kubernetes resources, we can look at this article on why container memory usage is high.

Conclusion

In this article, we looked at different ways to update the image in a Kubernetes Deployment. We talked about updating the image tag in the manifest. We also used the kubectl set image command and did rollout restarts. These methods help us make the deployment process easier. They also make sure our applications run the latest versions well.

For more information, we can check our guides on deploying services in Kubernetes and Kubernetes pod troubleshooting.

Comments