BUILDING DOCKER IMAGES

 


Building Docker Images


1.About Docker Images

In the world of modern software development, Docker has become a powerful tool for packaging, deploying, and running applications in lightweight, portable containers. It allows developers to bundle an application along with all its dependencies into a single unit called a container, ensuring that it runs smoothly on any system—whether it’s a local machine, test server, or cloud platform.

Docker can automatically build images by reading a set of instructions written in a file called a

Dockerfile. This automation not only simplifies the deployment process but also ensures consistency across different environments.

Interestingly, Docker originated from a platform-as-a-service company called Dotcloud in 2013. What began as an internal tool eventually evolved into a revolutionary open-source technology. Today, almost every major company uses Docker as a part of their development and deployment workflow.

Just like virtual machines virtualize servers, Docker virtualizes the operating system, making it faster, more efficient, and less resource-heavy. This makes it a preferred choice for developers and DevOps engineers around the globe.

In the following blog, you will get familiar with the process of making a docker image.

2.Difference between Images and Containers

If you're new to Docker, the terms “images” and “container” might seem interchangeable. However, understanding the difference between the two is crucial for working effectively with Docker.

Let’s break it down simply:

A Docker image is a read-only template that contains the instructions for creating a container. You can think of it like a blueprint—it includes the application code, libraries, environment variables, and configuration files needed to run your application. It is static and does not change once it's built.

On the other hand, a Docker container is a runtime instance of that image. It's the live, working copy of the image. Once you run an image, Docker creates a container around it. Containers are isolated, lightweight environments that actually run your applications.

4. About Dockerfile:-

At the heart of every custom Docker image lies a simple but powerful tool: the   Dockerfile. This is a plain text file that contains a set of instructions telling Docker exactly how to build an image.

Think of a Dockerfile as a recipe for your application. Just like a cooking recipe lists ingredients and steps, a Dockerfile includes a series of commands and arguments that are executed in a specific order to create a fully functional image.

Following are some of the Dockerfile Instructions:-

  1. FROM:-  It sets the base image on which your image will run.

  2. WORKDIR:- It sets the working folder inside the container.

  3. COPY:- Copy files and folders from your system.

  4. RUN:- Runs the command while building.

  5. CMD:- Starts your app when the container runs.


5.Steps to build Docker image and push it to Docker hub.

Here we will be taking a simple python image example to how to build a Docker image.

          Step 1:- Create the directory.

Fig 1:- Creating a directory

$ mkdir docker-example

Once inside the directory, you can begin adding files like Python scripts and Dockerfiles. This is where you’ll spend most of your time during the setup process.



 Step 2:-Open the directory.

                                                                                                                 Fig 2:- Opening the directory

$ cd docker-example

Once inside the directory, you can begin adding files like Python scripts and Dockerfiles. This is where you’ll spend most of your time during the setup process.


          Step 3:- Create a text file. 


Fig 3:- Creating a textfile

$ notepad "main.py"


The text file is where your application logic lives. In our example, we’ll write a small Python script that prints a simple message. This script will later be run inside a Docker container, which means you can share and run this code on any machine that has Docker installed—no setup required.


 Step 4:- Write the sentences.    


              

Fig 4:- Writing the code 


 Writing a simple Python print statement helps verify that the Docker setup is working correctly. It’s like a mini test run to check if everything is functioning.



           Step 5:- Create a Dockerfile

Fig 5:- Creating the Dockerfile

$ notepad Dockerfile


The Dockerfile is the brain of the Docker image. This is where you define everything your app needs—like the Python environment and code files.


          

           Step 6:-Write the Dockerfile instructions 


Fig 6:-  Writing the instructions 

 Each Dockerfile instruction serves a specific role. The base image defines the environment, while other commands like COPY, RUN, and CMD help automate the setup process. The goal is to create a reliable, repeatable environment where your application will work exactly as intended. 


           Step 7:- Build the image

               

Fig 7:- Building the image 

$ docker build -t python-docker-demo .


This step converts your Dockerfile and code into a portable image. If the build is successful, it means your instructions were correct and Docker can now package your app.



          Step 8:- Run the image

Fig 8:- Running  the image

$ docker run python-docker-demo


Running the image creates a container, which is like a mini-computer running your app. You’ll see the output of your Python file here—proof that everything works!


          Step 9:- Open the Docker login

Fig 9:- Opening the Docker 

$ docker login

Docker Hub is a public repository for sharing Docker images. By pushing your image to Docker Hub, you make it accessible from anywhere. This means you (or others) can pull and run the image on a different system without having to build it again

Step 10:- Push the image on Docker Hub

Fig 10:- Pushing the image on Docker Hub

$ docker tag python-docker-demo yourdockerhubusername/python-docker-demo:latest

$ docker push yourdockerhubusername/python-docker-demo:latest


Pushing the image uploads it to Docker Hub so others (or your future self) can download and run it easily from anywhere. It's like publishing your project for the world to use.


            Step 11:-Check on Docker Hub

Fig 11:- Checking on the Docker Hub

Once pushed, your image will appear in your Docker Hub account. You can now share the image name with teammates, or even pull it from a different machine.


6. Conclusion

Building Docker images is a fundamental skill in today’s DevOps and development landscape. By understanding the difference between images and containers, mastering Dockerfile instructions, and following a structured image creation workflow, you can easily package and deploy applications across any environment. Docker not only simplifies application distribution but also enhances consistency, portability, and scalability. Whether you're working on a personal project or deploying enterprise-grade solutions, Docker empowers you to deliver software more efficiently and reliably. Start experimenting with your own images—and unlock the true potential of containerization. Docker is widely used in real-world scenarios: from web development to machine learning, and even in IoT and game development. Major platforms like Netflix, Spotify, and PayPal use Docker to deploy scalable and resilient applications. Learning Docker not only boosts your skills but also prepares you for modern development workflows.

Comments

Post a Comment

Popular posts from this blog

CONTAINERISING A BACK-END WEB APPLICATION USING DOCKER COMPOSE

Image
                CONTAINERISING A BACK-END WEB         APPLICATION USING DOCKER COMPOSE   INTRODUCTION:           In today's digital world, applications like websites, mobile apps, and online services rely on many small pieces working together — such as the code that runs the app, the database that stores the information, and the environment where everything runs smoothly. Managing all of these parts can be difficult, especially when moving from one computer to another or from a developer's laptop to a server in the cloud. That’s where containerization comes in. In simple words, containerization is like putting your entire application — along with everything it needs to run — into a tightly sealed box (called a container ). This box can then run the same way on any computer, anywhere in the world. It removes the “it works on my machine but not on yours” problem. ...
Read more

RUNNING A PROGRAM USING DOCKER AND COMPOSE

Image
                                                  From Code to Container: Running a Program Using Docker and Compose  By Ayushi Singh - August 31, 2025 ABOUT DOCKERS A Docker build is kind of like telling Docker how to make your app into something that can run anywhere — like packing it all into a neat little box. You give Docker your code, maybe some files it needs, and a list of instructions (in a file called a Dockerfile ). Then Docker follows those steps — like installing stuff or compiling your code — and builds an image, which is like a ready-to-go version of your app. You can then run this image on any computer that has Docker, and it’ll work the same way every time.It’s a super handy way to avoid the “it works on my machine” problem and keep things nice and portable. PURPOSE OF THIS PROJECT When we think of Docker, we usually imagine modern web apps,...
Read more