Do You Want to Continue This Operation Dockerfile

We can use the Docker commit command to commit changes to Docker containers. Consider the following situation. When you want to run an application inside Docker containers, you might have to install packages and dependencies inside the container. Initially, you can use Dockerfile instructions to install these packages directly. However, once you have created a container, it's not possible to keep making changes inside the Dockerfile every time you want to install something inside the container.

Also, as soon as you exit the container, all the changes inside it are lost immediately. So, you will have to go through the same process again and again. Hence, if you want the changes to persist, you can use the Docker commit command. The commit command will save any changes you make to the container and create a new image layer on top of it.

Suppose you want to create a file inside an Ubuntu container and you want this file to remain inside the container even after you exit it. In such a case, before you exit a container, you can invoke the container commit command to save the changes. So the next time you open the container, you will find your file there.

In this article, we will discuss how to save changes to an image using the Docker commit command with examples. You can also check out our complete and free Docker Tutorials.

Docker Commit Command

As already discussed, we can use the Docker commit command to commit changes made in a container to create a new image. The data contained inside mounted volumes are not included by the commit operation. Also, the commit command will first pause all the processes running inside the container and then commit the changes. In this way, it ensures that data corruption does not take place. If we want to change this default behavior, we can use the –pause option.

We can also apply Dockerfile instructions directly inside the commit command using the –change option. Hence, if you want to run a Dockerfile instruction during the commit process, you can easily do so using the –change option.

The syntax of the Docker commit command is –

          $ docker commit [OPTIONS] CONTAINER [REPOSITORY[:TAG]]        

We can use options such as –

Name	Shorthand	Description
--author	-a	To mention the name of the author (e.g., "TechTutorialSite <techtutorialsite@gmaile.com>")
--change	-c	It can be used to apply Dockerfile instructions while committing changes to the created image.
--message	-m	It can be used to commit a message.
--pause	-p	You can choose to pause the container during the commit process.

Docker Commit Command Options

Docker Commit Example

We will try to create an Ubuntu container and make some changes inside it. We can create a new file or a directory inside the container. Next, we will use the commit command to save changes to a new image. Let's first list all the images.

          $ docker images        

List all Docker Images

Now, let'screate an Ubuntu container using the Docker run command.

          $ docker run -it --name=myubuntu ubuntu bash        

Run an Ubuntu container

We now have access to the bash of our Ubuntu container. Let's create a file with some content.

          # echo "Welcome to Docker Tutorials by TechTutorialSite" > TechTutorialSite.txt # ls # cat TechTutorialSite.txt        

Making Changes inside a Containers

Now, keeping this container running, let's open a new terminal and execute the docker commit command to save changes to a new image.

          $ docker commit myubuntu myubuntuimage:version1        

Docker Commit Command

You can see that our new image has been created successfully. Let's create and run a container associated to this new image to verify the changes.

          $ docker run -it --name=myubuntuv1 myubuntuimage:version1 bash        

Verify container changes

Let's try to list all the files and print the new file content.

          # ls # cat TechTutorialSite.txt        

Changes Committed

You can see that the changes that we made to the previous container has now been committed to the new image.

Commit a Docker Container with Dockerfile Instructions

We can use the –change option along with the Docker commit command to pass Dockerfile instructions to the new image. Let's try to set the debug environment variable to True using the ENV instruction. We can pass this instruction using the Docker commit command.

          $ docker commit --change "ENV DEBUG=true" myubuntuv1 myubuntuimage:version2        

Commit a Docker Container with Dockerfile Instructions

Let;s try to verify the changes made to the environment variable by using the Docker inspect command.

          $ docker inspect -f "{{ .Config.Env }}" myubuntuimage:version2        

Changes Committed

You can see that the debug environment variable for the new committed image has now been set to true.

Final Thoughts!

If you want to make changes inside the container and want those changes to persist, you can use the Docker commit command. This will create a new image with all the changes made to the previous container committed to it. Once you create and run a new container associated with the new image, you will find that all the changes have now been saved.

If you have any queries or suggestions, please mention them in the comment box and we will have our experts get back to you as soon as possible. Also, check out our free Docker Tutorial.

Helpful Articles –

1. How to Build Docker Images?
2. How to start a Docker container?
3. Important Docker Image Commands

danielplinted.blogspot.com

Source: https://techtutorialsite.com/docker-commit-changes-to-containers/

Bagikan Artikel ini