How to build Docker image using Dockerfile?

Building Docker Images using Dockerfile

Building Docker images using a Dockerfile is a straightforward process that allows you to automate the creation of your application's runtime environment. A Dockerfile is a text file that contains a set of instructions for building a Docker image. These instructions define the base image, install necessary dependencies, copy application code, and configure the runtime environment.

Here's a step-by-step guide on how to build a Docker image using a Dockerfile:

1. Create a Dockerfile

The first step is to create a Dockerfile in the root directory of your project. The Dockerfile should contain the necessary instructions to build your Docker image. Here's an example Dockerfile for a simple Python web application:

# Use the official Python image as the base image
FROM python:3.9

# Set the working directory to /app
WORKDIR /app

# Copy the requirements file into the container
COPY requirements.txt .

# Install the Python dependencies
RUN pip install --no-cache-dir -r requirements.txt

# Copy the application code into the container
COPY . .

# Expose the port that the application will run on
EXPOSE 5000

# Set the command to run the application
CMD ["python", "app.py"]

In this example, the Dockerfile:

1. Uses the official Python 3.9 image as the base image.
2. Sets the working directory to /app.
3. Copies the requirements.txt file into the container.
4. Installs the Python dependencies listed in the requirements.txt file.
5. Copies the application code into the container.
6. Exposes port 5000 for the application to listen on.
7. Sets the command to run the app.py script when the container starts.

2. Build the Docker Image

Once you have created the Dockerfile, you can build the Docker image using the docker build command. Navigate to the directory containing the Dockerfile and run the following command:

docker build -t my-app .

This command will build the Docker image with the tag my-app using the Dockerfile in the current directory.

The -t option allows you to assign a tag (name) to the image, which can be used to reference the image later.

3. Verify the Image

After the build process is complete, you can list the available Docker images on your system using the docker images command:

docker images

This will display a list of all the Docker images on your system, including the my-app image you just created.

4. Run the Docker Container

Finally, you can run the Docker container based on the my-app image using the docker run command:

docker run -p 8080:5000 my-app

This command will start a new container based on the my-app image and map port 8080 on the host machine to port 5000 inside the container. You can then access your application by visiting http://localhost:8080 in your web browser.

The docker run command can be customized with various options to configure the container's runtime environment, such as setting environment variables, mounting volumes, or running the container in the background.

By using a Dockerfile to build your Docker images, you can ensure that your application's runtime environment is consistent across different environments, making it easier to deploy and scale your application.