How To Build Docker Image: A Step-by-Step Tutorial

How To Build Docker Image

I am going to tell you simple ways to build Docker images. Docker has become the tool to transform how we package, deploy, and run applications.

Though Docker didn’t invent the concept of containerization, it made it more accessible.

I’ll walk you through crafting Docker images from scratch, deploying them as containers, and doing it all like a pro.

This brings portability, consistency, and simplicity to the heart of your development workflow.

By the end of this guide, you will know how to use Docker like a pro. You must understand that many companies promote Docker images, and your dream company could be one of them.

Learn the concept of Docker from experts using the KodeKloud coupon.

Understanding Docker Image Building Fundamentals

Let me tell you the basic concept and structure of Dockerfile and mention Docker image layers. 

Dockerfile Concept

Dockerfile is a fundamental component that serves as a text-based instruction manual in the Docker image. 

A Dockerfile is essentially a script containing a series of commands and arguments that guide Docker in automatically constructing an image. 

This file is named “Dockerfile” without any extension, and its contents dictate the steps needed to assemble the desired environment.

Dockerfile InstructionExplanation
FROMUsed to get the base image from a container registry, like Docker Hub, GCR, Quay, ECR, and more.
RUNRuns commands while building the image.
ENVSets variables inside the image that are available both during the build and when the container is running. If you only want to set variables during build time, use the ARG instruction.
COPYCopies files and folders from my computer to the image.
EXPOSESays which port should be made available for the Docker container.
ADDIt’s an advanced version of the COPY instruction. It not only copies files but can also fetch from a URL and automatically extract tar files. However, it’s usually better to use COPY instead of ADD. If you need to download files from the internet, it’s recommended to use curl or get with RUN.
WORKDIRChooses the present working directory. You can use this in a Dockerfile to pick a different working directory. Once you set WORKDIR, commands like RUN, CMD, ADD, COPY, or ENTRYPOINT will work in that chosen directory.
VOLUMEIt’s used to make or connect a volume to the Docker container.
USERChooses the username and user ID for running the container. You can use this to pick a non-root user for the container.
LABELIt’s used to provide details about the Docker image, like metadata information.
ARGIs employed to define build-time variables with key and value. The ARG variables won’t be accessible during the container’s runtime. If you wish to keep a variable in a running container, go for ENV.
SHELLThis command is utilized to configure shell options and the default shell for subsequent RUN, CMD, and ENTRYPOINT instructions.
CMDIt runs a command inside a running container. Only one CMD is allowed; if there are multiple, only the last one counts. It can be changed using the Docker CLI.
ENTRYPOINTDecides the commands to run when the Docker container begins. If you don’t specify any ENTRYPOINT, it defaults to /bin/sh -c. You can also change the ENTRYPOINT using the –entrypoint flag in the CLI. For more details, check out CMD vs ENTRYPOINT.

Dockerfile Structure

A Dockerfile comprises instructions and their corresponding arguments. Everything on the left side of the Dockerfile is an instruction, while the right side represents the arguments for those instructions. 

The simplicity of this structure makes it easy to comprehend and allows for the seamless automation of image creation. To initiate the Docker image-building process, one must first install Docker. 

While Docker is native to Linux, versions like Docker for Mac and Docker for Windows exist for those operating systems.

Docker Image Layers

Docker images are constructed using a layered architecture, and understanding these layers is crucial to grasp the essence of Docker image building.

Each layer represents a specific set of instructions and contributes to the overall image.

A Docker image can be seen as a blueprint outlining the essential components and configurations required for an application or service.

When a Docker container is created from an image, it adds a writable layer on top.

This writable layer allows the container to have its file system modifications and configurations while still inheriting the underlying image’s core components.

These layers are incremental and cached, enhancing the efficiency of the Docker image-building process.

Subsequent builds can reuse existing layers, minimizing redundancy and significantly speeding up the creation of images.

The distinction between Docker containers and images is crucial. Docker containers are instances of Docker images, whether in a running or stopped state. 

Containers have a writable layer, making them dynamic entities where software is executed.

On the other hand, Docker images serve as immutable blueprints, capturing the static configurations and dependencies needed for containerized applications.

Suggested read:

Prerequisites for Building a Docker Image

Before you go on with the process of building a Docker image for Integration Server, make sure you’ve got the following basics covered:

Install Docker

Firstly, ensure Docker is running on the machine where you plan to set up the Integration Server. Install Docker, and don’t forget to start it as a daemon.

If you’re unsure how to do this, plenty of guides are available to help you with the installation process.

Set Up Integration Server

Ensure the Integration Server is installed on your system along with the necessary packages.

Follow the step-by-step instructions in the “Installing Software AG Products” guide for Linux, UNIX, or Windows Server 2016.

Once the installation is done, configure the Integration Server and any hosted products according to your needs.

Specify Integration Server Services

An Integration Server within a Docker container in Integration Cloud can expose specific consumer services. So, specifying these services before building the Docker image is important.

Context Preparation

Understand the concept of the Docker build context. This is the set of files and directories needed during the image-building process.

Ensure all necessary files are organized and ready in the build context, including your Dockerfile.

Building Docker Images with Dockerfile

I’ll guide you through building a Docker image with a practical example in this part. Together, we’ll craft a Nginx Docker image from the ground up, complete with a personalized index page.

Let me walk you through the steps to construct this Docker image:

Let’s kick off our Docker image journey with the first step:

Step 1: Setting Up the Workspace

Firstly, let’s create the necessary folders. Open your terminal and enter these commands:

mkdir nginx-image && cd nginx-image

mkdir files

Now, let’s make a file named `.dockerignore`:

touch .dockerignore

Step 2: Preparing Code and Configuration

Now, let’s set up our project code and configuration. For practical projects, this is where you’d include your application files.

However, for our demo, we’ll keep it simple by creating an HTML file and a configuration file.

Navigate to the ‘files‘ folder:

cd files

Create an ‘index.html‘ file using the command:

vi index.html

Inside 'index.html', enter the following content and save the file:






    <div class="container">

      <h1>My App</h1>

      <h2>This is my first app</h2>

      <p>Hello everyone, This is running via Docker container</p>




Next, let’s create a configuration file named default:

vi default

Copy and paste the following contents into ‘default‘ and save the file:

server {

    listen 80 default_server;

    listen [::]:80 default_server;

    root /usr/share/nginx/html;

    index index.html index.htm;

    server_name _;

    location / {

        try_files $uri $uri/ =404;



Our basic HTML code and Nginx configuration are ready.

Step 3: Selecting the Foundation Image

Now, let’s move on to a crucial decision: choosing the base image. In Docker, we use the `FROM` command in the Dockerfile to specify the base image.

Consider it the starting point for building our image, similar to selecting a virtual machine image when creating VMs on the cloud.

For our project, the choice of a base image attaches to our application’s needs and the preferred operating system. In this instance, we’ll opt for the `ubuntu:18.04` base image. 

This choice aligns with our project requirements and sets the stage for building our Docker image. 

Step 4: Crafting the Dockerfile

Let’s take a decisive step forward by creating our Dockerfile in the ‘nginx-image‘ folder. Open your terminal and use the following command:

vi Dockerfile

Now, let’s put life into our Dockerfile with the following content:

FROM ubuntu:18.04  

LABEL maintainer="[email protected]" 

RUN  apt-get -y update && apt-get -y install nginx

COPY files/default /etc/nginx/sites-available/default

COPY files/index.html /usr/share/nginx/html/index.html


CMD ["/usr/sbin/nginx", "-g", "daemon off;"]

Explanation of Each Step:

  • LABEL: Adding metadata about the maintainer (not mandatory, but informative).
  • FROM: Pulling the Ubuntu 18.04 version image from Docker Hub.
  • RUN: Updating and installing Nginx.
  • COPY: Transferring Nginx default config and our index.html from the local ‘files’ directory to the image.
  • EXPOSE: Declaring port 80 as Nginx listens on that port.
  • CMD: Launching the Nginx server when the Docker image starts. The ‘daemon off;’ directive keeps the process in the foreground for easy log monitoring.

This Dockerfile is the backbone of our Docker image, defining each crucial step in its creation.

Step 5: Bringing Your Docker Image to Life

Our folder and file structure are now neatly organized for image creation:


├── Dockerfile

└── files

    ├── default

    └── index.html

Now, let’s bring our Docker image into existence. Execute the following command in your terminal:

docker build -t nginx:1.0 .

Breaking down the command:

  • -t is for tagging the image.
  • nginx is the name we give to the image.
  • 1.0 is the tag name. If no tag is specified, it defaults to ‘latest’.
  • The dot . at the end refers to the Dockerfile location as the build context, which is our current directory.

If your Dockerfile resides in a different folder, specify it like this:

docker build -t nginx /path/to/folder

To view your newly born image, list the images using:

docker images

You can observe the tag as ‘1.0’. For a specific tag, use:

docker build -t nginx:2.0 

Consider using semantic versioning (Semver) for image tagging. Docker caches build steps, making subsequent builds faster. 

Large images slow down deployment, so optimizing is a good practice. 

Step 6: Testing Your Docker Image

Fantastic job! Now that our Docker image is crafted, let’s see it in action. Run the following command:

docker run -d -p 9090:80 --name webserver nginx:1.0

Breaking it down:

  • -d flag runs the container in detached mode.
  • -p flag specifies the port mapping in the format local-port:container-port.
  • –name gives your container a name; here, it’s ‘webserver.’

To check the container status, use:

docker ps

Now, open your browser and visit http://<host-ip>:9090. Behold! Your custom HTML page is seamlessly served by Nginx within the Docker container.

You’ve successfully built, run, and tested your Docker image. Create a self-signed certificate by following our guide.

Advanced Docker Image Building Techniques

Let’s explore some advanced techniques in Docker image building that go beyond the basics.

Build Arguments

Build arguments allow you to configure instructions in your Dockerfile dynamically during the build process. They act like variables that can be set when initiating the build.

This flexibility is valuable when you want to customize aspects of your image without modifying the Dockerfile itself.



FROM my-base-image:${APP_VERSION} AS builder

RUN build-my-app

In this example, the APP_VERSION build argument lets you specify the version of your application during the build.

Environment Variables

Setting environment variables in your Dockerfile is crucial for controlling application behavior and configuration.

They provide a way to pass dynamic values to your application inside the container, making it adaptable to different environments.


ENV DB_HOST=localhost \

    DB_PORT=5432 \

    DB_USER=myuser \


RUN configure-database

Here, environment variables are used to configure the database connection parameters. 

Adjusting these variables during the build or runtime can customize the application’s behavior.

Volume Mounting

Volume mounting in Docker involves attaching external volumes to containers, allowing for persistent data storage. This is particularly useful when you want to separate data from the container, ensuring that important information is retained even if the container is stopped or removed.


FROM my-base-image

VOLUME /data

CMD ["run-my-app", "--data-dir", "/data"]

A volume is mounted at /data. This allows external data to be stored outside the container, providing durability and flexibility. 

These advanced techniques enhance the versatility and efficiency of Docker image building. Find the best resource and Cka Exam Study Guide.

Troubleshooting Docker Image Build Errors

You can use the following tricks to troubleshoot docker image build errors:

Common Build Errors

Understanding and addressing common issues is critical when encountering errors during a Docker build. Here are some typical mistakes and ways to resolve them:

Unresolved Images:

When Docker can’t find or download specified images, you should double-check image names and ensure they are accessible. Also, check your internet connection.

Missing Dependencies:

When the required dependencies or files are absent, you should review your Dockerfile for missing instructions or dependencies. Ensure all necessary files are included.

File Permission Issues:

If the Docker build fails due to permission problems on files, you can try adjusting file permissions in your Dockerfile or use the `–chown` option in commands to set appropriate ownership.

Debugging Build Failures

To troubleshoot build failures effectively:

Analyze Build Logs:

  • Read the error messages provided by Docker after a failed build.
  • Look for specific error details to pinpoint the issue.

Inspect Intermediate Containers:

  • Use `docker run` interactively with the image built so far.
  • Investigate the container environment to identify problems.

Use Debugging Tools:

  • Employ the `–verbose` option for more detailed output.
  • Use Docker’s debugging tools to analyze and understand each build process step.

Error Prevention Strategies

Preventing Docker build errors is as essential as troubleshooting them:

Thorough Dependency Management:

  • Specify dependencies in your Dockerfile. 
  • Use versioning to avoid unexpected updates.

Proper File Permissions:

  • Set appropriate file permissions in your Dockerfile to avoid permission-related issues.

Image Caching:

  • Use the `–no-cache` option cautiously. 
  • It forces a rebuild but may slow down the process.

Consistent Environment:

  • Ensure a consistent build environment, including Docker versions and base images.

You can troubleshoot Docker image build issues by recognizing common errors, employing debugging techniques, and implementing error prevention strategies. 

Optimizing Docker Image Performance

Optimizing both size and runtime performance is essential for efficient containerization of Docker images. Here are some simple techniques to enhance your Docker image performance:

Image Size Optimization

Choose the Right Base Image:

Opt for lightweight base images to minimize unnecessary overhead.


     FROM node:14-alpine

Minimize the Number of Layers:

Combine multiple instructions into a single one to reduce the number of layers.


         RUN apt-get update && \

         apt-get install -y git && \

         apt-get clean && \

         rm -rf /var/lib/apt/lists/*

Use Multi-Stage Builds:

Utilize multi-stage builds to create smaller images and only copy necessary files between stages.


     # Build stage

     FROM node:14-alpine as build


     # Production stage

     FROM node:14-alpine as production


Runtime Performance Optimization

Leverage Build Cache:

Place stable instructions at the top to leverage Docker’s build cache and speed up the build process.


     COPY package*.json ./

     RUN npm install

     COPY . .

Remove Unnecessary Files:

Keep your Docker image lean by excluding unnecessary files like build artifacts and logs.


     # In a multi-stage build, copy only necessary files to the production stage

     COPY --from=build /app/dist ./dist

Image Caching and Reuse

Leverage Docker Build Cache:

Take advantage of Docker’s caching mechanism by copying stable files before more volatile components.


     COPY package*.json ./

     RUN npm install

     COPY . .

Minimize Build Times:

Efficient use of caching and reusing intermediate layers minimizes build times, improving overall build efficiency.

By applying these optimization techniques, you can create Docker images that not only have a smaller memory footprint but also deliver improved runtime performance. 


Building Docker images has been a valuable journey for me, offering numerous benefits that enhance the efficiency and performance of my containerized applications.

You can easily optimize image size, improve performance, and troubleshoot effectively. 

The future of Docker image building holds exciting possibilities. Automated image building is emerging as a trend, offering a more seamless and hands-free approach to containerization. 

I encourage you to take the knowledge gained here and use it on your journey to Build Docker Image.

Explore the benefits of lightweight images, experiment with multi-stage builds, and delve into CI/CD integration.

Suggested read:

Leave a Reply

Your email address will not be published. Required fields are marked *


Copyright 2024 © DevopsCloudCoupons All Rights Reserved.