Differences between a Dockerfile, Docker Image and Docker Container


Being able to identify what something is can lead to learning complex topics faster. Here's how these 3 Docker concepts tie together.

In casual conversation you may hear phrases like:

  • “Yeah, I’m using Docker containers”
  • “Yay, I built my app with Docker”
  • “I have many Docker images being used in production”
  • “Sure, let’s get the containers up and running”

While none of those phrases are technically wrong, they don’t really tell you the full story on how a few Docker related files and concepts tie together and it can be very confusing to learn something new when you hear phrases like that used all over the place.

I don’t know about you, but I learn best when I can identify and relate to whatever I’m trying to learn. It’s that magic thing that lets me go from thinking “…WTF am I reading?” to using it to solve my own problems without any trouble.

So let’s see how a Dockerfile, Docker image and Docker container all come together.

It All Starts With a Dockerfile

A Dockerfile is a file that you create which in turn produces a Docker image when you build it.

Just by breaking down that sentence we can start making a few assumptions, such as:

  • A Docker image can be created by taking 2 actions
    • The first action is to create a thing called a Dockerfile
    • The second action is to run some type of build command that uses the Dockerfile
  • A Docker image is a file or file-like thing, since it gets “built”

Those assumptions are correct, but let’s put them on the back burner for now and talk a little bit more about the Dockerfile.

A Dockerfile is a text file that Docker reads in from top to bottom. It contains a bunch of instructions which informs Docker HOW the Docker image should get built.

You can relate it to cooking. In cooking you have recipes. A recipe lets you know all of the steps you must take in order to produce whatever you’re trying to cook.

The act of cooking is building the recipe.

A Dockerfile is a recipe (or blueprint if that helps) for building Docker images, and the act of running a separate build command produces the Docker image from that recipe.

If You Build It, They Will Run (Usually)

The act of running a Docker image creates a Docker container, that’s it.

Here’s an easy thing to relate to if you’re a software developer:

In the world of object oriented programming, you often deal with classes. You can think of a Docker image as a class, where as a Docker container is an instance of that class.

Personally I’m not a fan of that analogy because it’s not the most accurate thing in the world but sometimes having a “good enough” relation is enough to grasp something and that analogy is definitely “good enough”.

So at the end of the day, we can sum things up as:
  • A Dockerfile is a recipe for creating Docker images
  • A Docker image gets built by running a Docker command (which uses that Dockerfile)
  • A Docker container is a running instance of a Docker image

If you want to identify and see how a few different Docker tools work together then check out another article I put together that lets you get to know Docker’s ecosystem.

Free Intro to Docker Email Course

Over 5 days you'll get 1 email per day that includes video and text from the premium Dive Into Docker course. By the end of the 5 days you'll have hands on experience using Docker to serve a website.