The images of Docker are immutable. When they are built, they don’t change. It also ensures consistency, predictability and stability of a . Similarly, every container made from the same image behaves exactly as it does; versioning is safe and easy to use. What if you have to tweak something inside a running container (such as installing / updating – configuration)? That’s where docker commit is in. For example, it allows you to capture changes in a running container and create re-image without touching the original image. I can use this for testing fixes, iterating quickly and rolling out custom images without rebuilding from scratch.
Why Docker Images Don’t Change
Several read-only layers are used in Docker images to create multiple different types of photos. Docker also adds a thin writable layer on top of the container layer when you run. What do you change just here in this top layer is the only one where you make a change? If all changes in that layer are removed once the container is deleted, then all of those changes will be untouched and the original image remains unchanged.
This design guarantees several benefits:
- Every container from the same image behaves the same, ensuring consistency.
- Changes in one container don’t affect others, providing predictability.
- You can safely tag specific image versions without risk.
A great stability, but when you want to make quick changes in a running container it’s very hard to get this design. docker commite helps that’s where help.
Creates a New Image From a Running Container
When you run the command docker commit, Docker captures current state of a running container and generate an image from it. A new image layer is a snapshot of the container’s file system, saving any changes you made such as installed packages, updated configurations or modified files. So, this way, the original image is not re-administered; so you can try and iterate quickly.
It’s the best way to save a custom base setup for future reuse, small fixes or configuration changes in testing (or sharing updated images with your team without having to rebuild drc Dockerfile from scratch)?
You can use the docker commit command with the following syntax to create a new image from a running container:
docker
commit
[
OPTIONS
]
CONTAINER_ID NEW_IMAGE_NAME
[
:TAG
]
The name or ID of the container you want to capture here is CONTAINER_ID; it’s called ‘NEW_IMAGERYNAME, which will be your choice for the new image and – with default being latest- is optional.
Note: docker commit is a legacy alias for docker container commit; both are identical.
The docker commit command provides several options to add metadata, apply configuration changes and control how the commit process works. A summary of all supported options is presented in the table below.
| Option | Long Form | Description | Example |
| — | — | — | — |
| -a | –author | Adds the author name to the new image metadata. | docker commit -a "Anees" my-container my-image |
| -c | –change | Applies Dockerfile instructions like ENV, LABEL, or CMD to the new image. | docker commit -c "ENV APP_ENV=prod" my-container my-image |
| -m | –message | Adds a short message describing the changes made in the image. | docker commit -m "Installed curl" my-container my-image |
| -p | –pause | Pauses the container during commit to ensure consistency (default: true). | docker commit --pause=false my-container my-image |
See How docker commit Works
What if you have an idea to install curl in an Alpine container without rebuilding your Dockerfile? Do so with a container from the base image run ‘from this on top of my , to do this.
docker
run
-it
alpine:latest
/
bin
/
sh
Once you are in the container, make the necessary changes:
apk update
&&
apk add curl
Now exit the container:
exit
After this, commit the container as a new image:
docker
commit
<
container_id
>
alpine-with-curl:
1.0
Verify your new image:
docker
images
Now, you have a new image ready to run anywhere, with curl pre-installed.
Run Your New Image to Test Saved Changes
After creating your new image, you can run a container from it to verify that your changes are saved.
docker
run
-it
alpine-with-curl:
1.0
/
bin
/
sh
This command opens an interactive shell inside a container based on the alpine-with-curl1 (independent) type of . Pictured 0 . Upon entering, you can check that your modifications have been made.
curl
--version
This demonstrates that changes are persisted in the new image.
docker commit vs Dockerfile: When to Use Which
The Dockerfile & docker commit both allow you to create Dockers images, but they work in very different ways and are suitable for various situations.
CI/CD pipelines, production environments and other repeatable builds are best for you to use A Dockerfile when you need reliable (and repeat-able) builders. All changes are also easily tracked and reviewed, and version-control over time because it maintains a clear definition of all changes in code. It is a way that this ensures that anyone who creates the image will be given the same result, which is important for long-term maintenance and team collaboration.
On the other hand, docker commit is good for quick fixes, testing or small adjustments you would like to make without rewriting or rebuilding an entire Dockerfile. That’s a good thing when you’re trying, debugging or validating if it is changing on the fly. But since these changes are not documented in a file, this is the best way to use short-term rather than production.
A nutshell is that you can use the most effective form of docker commit for experiments or temporary fixes in a tuck. Always use a Dockerfile for production-ready images. For the most out of Docker, it’s worth looking at other key commands that make working with containers, images and workflows easier.
Thanks for reading How to Make Persistent Changes to Docker Images Instantly
