How to build a Docker image from a Dockerfile?

1. Round up the application you want to Dockerize. Make sure it has all the necessary files / directories with their relevant dependencies.

1. At the root directory of your application, create a new file and name it `Dockerfile`. This file will house the necessary commands to assemble the Docker image.

1. Open your Dockerfile in a text editor and begin composing your Docker commands to assemble your image. Each Dockerfile must start from a base image, which could be an official Docker image like `ubuntu` or another image you created. Example of a simple `Dockerfile` might look like:

```

Use an official Ubuntu runtime as a parent image
FROM ubuntu:18.04

Set the working directory in the container to /app
WORKDIR /app

Copy the current directory contents into the container at /app
ADD . /app

Make port 80 available to the world outside this container
EXPOSE 80

Define environment variable
ENV NAME World

Run app.py when the container launches
CMD [“python”, “app.py”]
```
1. Save your Dockerfile and return to your command line.

1. Navigate to the root directory of your application in the console.

1. At the root directory, build your Docker image using the `docker build` command followed by `-t` and the name you want to give to your Docker image. Like this:

```
docker build -t your-image-name .
```

The `.` tells the Docker daemon to look for the Dockerfile in the current directory.

1. If the Docker image builds successfully, you should be able to see it listed if you run the `docker images` command.

1. To test the Docker image, you can create a container from it by running the command `docker run your-image-name`. If your Dockerfile uses the `EXPOSE` command to open any network ports, you can use the `-p` flag to map a host port to the container port. For example, `docker run -p 4000:80 your-image-name`.

Remember that building a Docker image requires a solid understanding of how Docker works and a good understanding of your application dependencies.