Devop Skills

How To Build Docker Image For Beginners? (Updated 2023)

Are you looking for an in-depth guide on how to build a Docker image step by step? Read on.

Docker is a software tool that enables the creation, distribution, and operation of lightweight application containers.

Find out the latest Linux Foundation coupon for up to 50% discount on site-wide certifications.

For those looking for a basic understanding of Docker, the Docker explained blog is an excellent resource to refer to.

So, let’s get started quickly.

How To Build Docker Image

What Is Dockerfile?

Dockerfile is the fundamental component required to create a Docker image. This is a straightforward text file containing directions and parameters, and Docker can automatically generate images by interpreting the instructions outlined within a Docker file.

In a Dockerfile, each left-hand side component represents an instruction, while each right-hand side component represents an argument corresponding to that instruction.

It is important to note that the filename for the Dockerfile should be “Dockerfile” without any file extension.

Listed below are crucial Dockerfile commands alongside their corresponding definitions for reference:

Dockerfile InstructionExplanation
RUNRuns instructions while the image is being constructed.
FROMTo designate the foundational image that can be obtained from a container registry such as Docker hub, GCR, Quay, ECR, and others.
ENVEstablishes environmental variables within the image, which will be accessible during both the building process and while the container is running. If solely build-time variables are desired, the ARG command should be utilized instead.
EXPOSEIndicates the port that should be made available for the Docker container.
COPYThe ARG command establishes key and value pairs for build-time variables. Note that ARG variables will not be accessible when the container is operational. To maintain a variable within a running container, the ENV command should be employed instead.
WORKDIRDefines the present working directory for the image. This command can be reused within a Dockerfile to specify an alternative working directory. Once the WORKDIR has been established, directives such as RUN, CMD, ADD, COPY, or ENTRYPOINT will execute within that particular directory.
ADDADD is a more comprehensive version of the COPY directive, which enables copying from a source URL and auto-extraction of tar files within the image. Nevertheless, it is suggested to employ the COPY command instead. If remote-file downloads are required, the RUN command may be used with curl or get.
VOLUMEIt is used to create or mount the volume to the Docker container
USERSets the user name and UID when running the container. You can use this instruction to set a non-root user of the container.
ARGADD is a more comprehensive version of the COPY directive, which enables copying from a source URL and auto-extraction of tar files within the image. Nevertheless, it is suggested to employ the COPY command instead. If remote-file downloads are required, the RUN command may be used with curl or get.
LABELSpecifies the username and UID utilized while operating the container. This instruction helps set a non-root user within the container.
ENTRYPOINTSpecifies the username and UID utilized while operating the container. This instruction helps set a non-root user within the container.
CMDSpecifies the username and UID utilized while operating the container. This instruction is helpful for setting a non-root user within the container.

To obtain a paid SSL/TLS certificate from a reputable certificate authority such as Verisign or Comodo, You can adopt this easy method to create self-signed certificates with OpenSSL.

How To Build Docker Image Using Dockerfile

Here are the simple and detailed steps to build a Docker Image using the Dockerfile.


Docker: Ensure you have Docker installed on your system. You can download and install Docker from the official Docker website.

Step 1: Create a Dockerfile:

The Dockerfile is a text file that contains instructions for building a Docker image. It specifies the base image, environment variables, application code, dependencies, and how to configure the image. Create a file named Dockerfile in the root directory of your project.

Here’s a basic Dockerfile example for a Python application:

# Use an official Python runtime as the base image
FROM python:3.8

# Set environment variables

# Copy the application code into the image

# Install application dependencies
RUN pip install -r requirements.txt

# Expose a port if your application listens on a specific port

# Define the command to run the application
CMD ["python", ""]

Now, you need to customize the Dockerfile to match the specific requirements of your application.

Step 2: Organize Project Files:

Place all the necessary files for your application in the project directory. In the example above, the requirements.txt file contains Python dependencies and is the main application script.

Make sure the Dockerfile and these files are in the same directory.

Step 3: Build the Docker Image:

Open a terminal and navigate to the directory containing the Dockerfile. Use the docker build Command to build the Docker image. Provide a name and tag for the image. For example:

docker build -t my-python-app:1.0 .
  • -t specifies the name and tag for the image.
  • my-python-app Is the name of the image.
  • 1.0 is the tag (version) of the image.
  • . indicates the build context (the current directory where the Dockerfile and project files are located).

Docker will execute the instructions in the Dockerfile and create a new image. This process may take some time, depending on the complexity of your application and the image’s size.

Step 4: Verify the Image:

To verify that the image was built successfully, you can use the docker images Command to list all the images on your system:

docker images

You should see your newly created image listed.

Check this guide, which will walk you through the installation of CRI-O Container Runtime on Ubuntu.

Step 5: Run a Container from the Image:

Once you have built the image, you can create and run containers. Use the docker run Command to start a container based on your image:

docker run -p 8080:8080 my-python-app:1.0
  • -p Maps a port from the host to the container (if your application listens on a specific port).
  • my-python-app:1.0 Specifies the image and tag to use.

Step 6: Access Your Application:

If your application exposes a web service on port 8080, you can access it in your web browser by navigating to http://localhost:8080 (or the host’s IP address).

Adjust the port number and address based on your application’s configuration.

WOW! You’ve successfully built a Docker image & created a running container from it.

As you know, the Docker simplifies the process of packaging, distributing, and running applications in isolated environments, making it easier to manage software deployments.

If you are a tech enthusiast like me, then you may be interested in getting a Linux certificate; here are the top Linux Certifications that I have curated to help you choose the best one.

What Are Some Dockerfile Best Practices?

Below, I have mentioned some of the best Dockerfile practices you must follow.

  1. Using a .dockerignore file to exclude unnecessary files & directories which can improve build performance.
  2. Only use trusted base images, and update them periodically to ensure your images remain secure.
  3. Consolidate instructions within the Dockerfile to minimize the number of layers & improve the build’s performance.
  4. You can run the container as a Non-Root User to avoid potential security breaches.
  5. Keep the image size small to reduce the attack surface and minimize the deployment time. Use minimal images and avoid installing unnecessary tools in your image.
  6. Use specific tags over the latest tag to prevent breaking changes over time.
  7. Avoid multiple RUN commands, as they generate multiple cacheable layers that can impact build efficiency.
  8. Do not share or copy sensitive information or application credentials in the Dockerfile. If necessary, add them to .dockerignore instead.
  9. Use EXPOSE and ENV commands as late as possible in the Dockerfile.
  10. Consider using a linter, such as hadolint, to check for common issues and best practices in your Dockerfile.
  11. Use a single process per container for easier management and monitoring and to keep the containers lightweight.
  12. Utilize multi-stage builds to create smaller and more efficient images.

What Are The Possible Docker Build Issues?

  1. Syntax errors or invalid arguments in the Dockerfile can cause the docker build command to fail with an error message. Correcting the syntax will typically resolve this issue.
  2. When using the docker run command, it is advisable to assign a name to the container to avoid potential problems that may arise when Docker automatically gives a name.
  3. Occasionally, the error message “Bind for failed: port is already allocated” may appear, indicating that another software or service is using the specified ports. You can check for any listening ports using commands such as netstat or ss, and either use a different port or stop the conflicting service.
  4. Another error that may occur is “Failed to download package,” which can arise due to various factors, such as a lack of internet access for the container or dependency issues. Troubleshooting these underlying causes can help resolve this error 💻.

Docker Image Registries

I recommend you select verified official base images for your application, as discussed in Step 1.

Many publicly available container registries offer officially verified base and application images, as listed in the following table.✅

RegistryBase Images
Google CloudDistroless base images
DockerDocker hub base images
Redhat QuayQuay Registry
AWSECR public registry

Bonus: To gain insight into Prometheus, an open-source monitoring framework that can effectively manage substantial amounts of data, consider reading our comprehensive guide on “Setting Up Prometheus Monitoring on a Kubernetes Cluster.”

Docker Image Vs. Containers

A Docker image is an executable package that contains all the necessary components to run an application, including its code, dependencies, tools, and other files.

When analyzed, you can see it is similar to a golden image in a virtual machine. The image comprises multiple read-only layers stacked on top of each other.

On the other hand, a Docker container is a running instance of a Docker image. Like virtual machines, containers are created from images. When a container is created from an image, it adds a writable layer on top of its read-only layers.

The main difference between an image and a container is that an image is read-only, while a container has a writable layer. This means that multiple containers can run from the same image, with each container having its writable layer separate from the others.

Containers can be deleted without affecting the underlying images. However, an image cannot run without a container. We can create multiple containers from the same image, each with its unique data and state.

Conclusion: Build Docker Image

In this article, I have covered everything on how to build a Docker Image and run an application as a Docker container using a Docker file with some best practices for writing a Dockerfile.

A strong understanding of Docker’s best practices is important for DevOps engineers when implementing them in a project.💻

Furthermore, understanding the process of building container images is essential for learning Kubernetes.

Frequently Asked Questions

How do we use base images from container registries other than the Docker hub?

The Docker engine is pre-configured with the Docker Hub container registry, so specifying the image name will result in the image being pulled from Docker Hub by default. However, if you wish to use an image from another container registry, you must provide the full image URL. For instance, you can use the following syntax: FROM

What is Docker build context?

The Docker build context refers to the location on the Docker host where the code, files, configurations, and Dockerfile are located during the Docker build process. The build context can be specified by either using a dot [.] or by providing the path to the folder. Additionally, the Dockerfile can be placed in a different location than the build context. To maintain best practices, it is recommended to keep only the necessary files in the build context to avoid including unwanted files and generating a larger Docker image.

How to build a Docker Image from a git repository?

It is possible to build a Docker image using a git repository using the docker build command. For a successful image build, the git repository must contain the Dockerfile and any necessary files.

Leave a Reply

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


Subscribe Newsletter

Copyright 2024 © Devopskills All Rights Reserved.


Avail a 20% instant discount on a huge training catalog using our special

Linux Foundation Coupons: UPWRITEZ20