How to change docker image

How to Modify Docker Images

I presume you are a tad bit familiar with Docker and know basics like running docker containers etc.

In previous articles we have discussed updating docker container and writing docker files.

What exactly is modifying a docker image?

A container image is built in layers (or it is a collection of layers), each Dockerfile instruction creates a layer of the image. For example, consider the following Dockerfile:

Since there are a total of three Dockerfile commands, the image built from this Dockerfile, will contain a total of three layers.

You can confirm that by building the image:

And then using the command docker image history on the built image.

Ignore the last ‘ ‘ layer.

Each of these layers is read-only. This is beneficial because since these layers are read-only, no process associated with a running instance of this image is going to be able to modify the contents of this image, therefore, these layers can be shared by many containers without having to keep a copy for each instance. But for the containers’ processes to be able to perform r/w, another layer is added on top of the existing RO layers when creating the containers, this is writable and not shared by other containers.

The downside of this r/w layer is that changes made in this layer is not persistent, although you can use volumes to persist some data, sometimes you may need/want to add a layer before some existing layer, or delete a layer from an image or simply replace a layer. These are the reasons one might want to modify an existing docker image.

In this article, I’m going to cover all the cases I mentioned above, using different methods.

Methods of modifying a docker image

There are two ways you can modify a docker image.

I’ll explain both methods, and at the end, I’ll also add which use case would be better for the method in context.

Method 1: Modifying docker image through the Dockerfile

Modifying a docker image essentially means modifying the layers of an image. Now since each Dockerfile command represents one layer of the image, modifying each line of a Dockerfile will change the respective image as well.

So if you were to add a layer to the image, you can simply add another Dockerfile instruction to it, to remove one you would remove a line and to change a layer, you would change the line accordingly.

There are two ways you can use a Dockerfile to modify an image.

Let me explain which method should be used when, and how.

1. Using an image as a base image

This is when you take the image you want to modify, and add layers to it to build a new child image. Unless an image is built from scratch, every image is a modification to the same parent base image.

This method is not going to be much helpful if your intention is to change or delete some existing layer. For that, you need to follow the next method.

2. Modifying the image’s Dockerfile

Since the existing layers of an image are read-only, you cannot directly modify them through a new Dockerfile. With the FROM command in a Dockerfile, you take some image as a base and build on it, or add layers to it.

Some tasks may require us to alter an existing layer, although you can do that using the previous method with a bunch of contradictory RUN instructions (like deleting files, removing/replacing packages added in some previous layer), it isn’t an ideal solution or what I’d recommend. Because it adds additional layers and increases the image size by quite a lot.

A better method would be to not use the image as a base image, but change that image’s actual Dockerfile. Consider again the previous Dockerfile, what if I did not have to keep Python3 in that image, and replace the Python3 package and the command with the Perl ones?

If built, there is going to be a total of five layers in this image.

Also, the size of the image is 83.8 MB.

Now instead of doing that, take the initial Dockerfile, and change the Python3 ones to Perl like so

The number of layers has reduced to 3, and the size now is 40.2 MB.

Image successfully changed.

The previous method is more useful when you’re going to just add layers on top of the existing ones, but isn’t much helpful when trying to modify the existing layers like delete one, replace one, reorder the existing ones and so on. That is where this method shines.

Method 2: Modifying image using docker commit

There’s this another method where you can take a snapshot of a running container, and turn that into an image of its own.

Let’s build a dummy:0.1 identical image, but this time without using a Dockerfile. Since I used alpine:latest as dummy:0.1 ‘s base, spin up a container of that image.

With the docker container commit command, you basically convert the outermost r/w layer to a r/o layer, append that to the existing image’s layers and create a new image. This method is more intuitive/interactive so you may want to use this instead of Dockerfiles, but do understand that this isn’t very reproducible. Also the same rules apply to removing or altering any existing layers, adding a layer just to remove something or alter something done in a previous layer is not the best idea, at least in most of the cases.

That concludes this article. I hope this one was helpful to you, if you have any question, do comment down below.

Using Docker Commit to Create and Change an Image

November 22, 2017

Stay connected

The Dockerfile is one of the key features to Docker’s success. The ability to build a new container image from a simple text file changed the technology game.

Starting with a Base Image

In today’s article, we are going to take a base Redis container image and add a new user to the container. While this example may be a bit generic, it shows how we can use the docker commit command.

Docker’s commit command allows users to take a running container and save its current state as an image. This means to add our new user, we will need a running container. To get started, let’s go ahead and launch a Redis container with the docker run command.

In the above command, we can see that we started a container in the background using the redis image. Let’s first verify that the container is in fact running with the docker ps command.

In the above output, we can see that the docker exec command worked, but what did it do? Let’s take a second to explore what exactly the above command does.

Now that we are logged into the container, let’s go ahead and verify if our «new» user already exists. We can do this by searching for the user’s username in the /etc/passwd file.

With the above output, we can see the user does not exist within this container.

Adding a User and Saving the Image

Since we have verified that the example user does not exist on a base redis container, let’s go ahead and add that user to our running container. To do this, we will use the useradd command.

If we once again execute the grep command against the /etc/passwd file, we should see this user now exists.

Now that our user is added, let’s go ahead and exit our container going back to the host system. From there, we can execute the docker commit command to save our image changes.

In the above output, we can see that the docker commit command returned a sha256 hash. Seeing this hash indicates that our docker commit command was successful.

Let’s double-check that our image was in fact created using the docker images command.

With the above, we can see our testredis image is in fact created.

!Sign up for a free Codeship Account

Seeing the Differences

With our new container image saved, let’s go ahead and see how well our docker commit worked. We can do this by issuing the same grep command via a docker run execution.

First, let’s verify that our same base redis container doesn’t have the example user.

From the above, we can see that the example user doesn’t exist within our base redis image. This might be a bit confusing at first, but once we think about how Docker works, it makes complete sense.

Earlier when we logged into our upbeat_panini container, we added the example user. When we did this, we only added that user to the running container. Any changes we make to a running container has no effect on the original image. This is essentially the stateless nature of Docker containers.

As expected, our new testredis:example image does include an example user. From here, we can use this image to create new containers or push it to a registry such as DockerHub.

Summary

Do you have another opinion or a use case that a Dockerfile doesn’t fit but docker commit does? Add your opinion in the comments below.

How to edit docker image in two ways

Spin up and run applications in split-seconds – That’s what makes Docker containers so popular among developers and web hosting providers.

In our role as Technical Support Providers for web hosting companies and infrastructure providers, we provision and manage Docker systems that best suit their purposes.

One of the key tasks involved in this Docker management services, is editing docker images. Today, we’ll see how we edit docker image for customer needs.

What is a docker image

Docker helps to easily create and run container instances with our desired applications. These containers are created using images.

A docker image is a package of code, libraries, configuration files, etc. for an application. The images are stored in repositories (storage locations).

Images can be downloaded from a repository and executed to create docker containers. So, in effect, a container is just a run-time instance of a particular image.

To create a Docker image, a Dockerfile is used. A dockerfile is a text document, usually saved in YAML format. It contains the list of commands to be executed to create an image.

How to edit docker image

The images provided by repositories are specific to a single instance type creation. In many scenarios, users need to edit these images to suit their needs.

For customizing or tweaking a docker image to specific requirements, we edit this docker image. But Docker has a drawback that an image cannot be directly edited or modified.

To edit Docker images, there are two ways:

1. Edit the Dockerfile

The most commonly used method is to edit the Dockerfile that is used to create the Docker image. This is a convenient and fool-proof method to edit docker image.

A sample Dockerfile for a Zabbix monitoring container would look like:

To modify the image used by an existing container, we delete that container, edit the Docker file with the changes needed and recreate the container with the new file.

In this sample Dockerfile, the image used to create the container is ‘zabbix/zabbix-agent:latest’. This image can be modified to another one or version by editing this file.

The ‘docker compose’ tool helps to manage multiple Docker containers easily using a single YAML Dockerfile. In cases where changes are to be made for only one container, it can be edited in the file.

After making changes to the image, only the corresponding containers need to be recreated and others can be left intact. The option “–no-recreate” is used for that.

As Docker containers are meant to be restarted and recreated, they cannot be used to store persistent data. The data in Docker infrastructure are usually stored in Docker volumes.

Storing the data in volumes outside the containers ensures that even when the containers are recreated, the data related to it won’t get affected.

This enables us to easily edit a docker image without losing the underlying data. Modifying Dockerfiles also helps to keep track of the changes made in the images.

Utmost care has to be exercised while modifying a Dockerfile, especially in the production environment, as a single mistake can mess up a normally functioning container.

2. Create a modified image

Another option to edit docker image is to run an existing image as a container, make the required modifications in it and then create a new image from the modified container.

a. First, create a Docker container from a parent image that is available in repository.

b. Then connect to the container via bash shell

c. From the shell, make the changes in the container as required. This can include installing new packages, modifying configuration files, downloading or removing files, compiling modules, and so on.

d. Once the changes are done, exit the container. Then commit the container as a new image. This will save the modified container state as a new image.

e. This modified image is then uploaded to a repository, which is then used for creating more such containers for future use.

Conclusion

Docker containers are widely used in DevOps and niche web hosting. Today we’ve discussed how our Docker Support Engineers easily edit docker images in our Docker infrastructure management.

Related posts:

PREVENT YOUR SERVER FROM CRASHING!

Never again lose customers to poor server speed! Let us help you.

Our server experts will monitor & maintain your server 24/7 so that it remains lightning fast and secure.

How to Commit Changes to a Docker Image with Examples

Home » DevOps and Development » How to Commit Changes to a Docker Image with Examples

When working with Docker images and containers, one of the basic features is committing changes to a Docker image. When you commit to changes, you essentially create a new image with an additional layer that modifies the base image layer.

In this tutorial, you will learn how to commit changes to a Docker image by following our simple examples.

Steps For Committing Changes to Docker Image

Step 1: Pull a Docker Image

To illustrate how to commit changes, you first need to have an image to work with. In this article, we work with the latest Ubuntu image for Docker. Download the image from Docker’s library with:

If you recheck the available images, you will see the Ubuntu image:

Copy IMAGE ID for later use.

Step 2: Deploy the Container

Add the IMAGE ID to the command that will create a container based on the image:

The –it options instruct the container to launch in interactive mode and enable a terminal typing interface. Upon executing the command, a new container launches and moves you to a new shell prompt for working inside of it.

Step 3: Modify the Container

Now that you are in the container, you can modify the image. In the following example, we add the Nmap software for network discovery and security auditing:

The command will download the Nmap package and install it inside the running container.

You can verify the installation by running:

The output shows you that Nmap version 7.60 is installed and ready to use.

Once you finish modifying the new container, exit out of it:

You will need the CONTAINER ID to save the changes you made to the existing image. Copy the ID value from the output.

Step 4: Commit Changes to Image

Finally, create a new image by committing the changes using the following syntax:

Therefore, in our example it will be:

Where deddd39fa163 is the CONTAINER ID and ubuntu-nmap is the name of the new image.

Your newly created image should now be available on the list of local images. You can verify by checking the image list again:

Now that you have learned how to commit changes to a Docker image and create a new one for future uses, take a look at our tutorial on how to set up and use Private Docker Registry.

Modifying a docker image

I have recently started working on docker. I have downloaded a docker image and I want to change it in a way so that I can copy a folder with its contents from my local into that image or may be edit any file in the image.

I thought if I can extract the image somehow, do the changes and then create one image. Not sure if it will work like that. I tried looking for options but couldn’t find a promising solution to it.

The current Dockerfile for the image is somewhat like this:

Note:- I am looking for an easy and clean way to change the existing image only and not to create a new image with the changes.

4 Answers 4

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

The above line in docker file tells Docker which image your image is based on. So, the contents from parent image are copied to new image

Finally, for including the test folder on local drive I added below command in my docker file

and the test folder was added in that new image.

Below is the dockerfile used to create the new image from the existing one.

Update:- For editing a file in the running docker image, we can open that file using vim editor installed through the above docker file

Now, the vim commands can be used to edit and save the file.