Docker: Concept of Dockerfile

Last Updated: 15th January, 2024

Welcome to the world of Dockerfile, a powerful tool in the realm of containerization! Dockerfile is a declarative script that serves as a blueprint for constructing Docker images, allowing you to encapsulate your applications and dependencies in a portable and reproducible manner. In this tutorial, we'll embark on a journey through the essential elements of Dockerfile, exploring commands that define the base image, set the working environment, copy files, install dependencies, and orchestrate the startup of your containerized applications. We'll delve into the art of crafting Dockerfiles, understanding their syntax, and unlocking the potential for creating efficient and scalable containerized solutions. Let's dive into the magic of Dockerfile and unleash the full potential of containerized development!

What is a Dockerfile?

A Dockerfile is a text document that contains all the commands a user could call on the command line to assemble an image. Essentially, it is a script of instructions that Docker reads to build an image automatically.

Dockerfile consists of specific commands that guide you on how to build a specific Docker image. These commands are written in a domain-specific language, called the Dockerfile syntax.

Dockerfile Example

Here's an example of a Dockerfile for a JavaScript application:

# Choose your base image
FROM node:14-alpine3.12

# Set the working directory in the Docker image
WORKDIR /usr/src/app

# Copy package.json and package-lock.json to the Docker image
COPY package*.json ./

# Install the application dependencies
RUN npm install

# Copy the rest of the application code to the Docker image
COPY . .

# Make port 8080 accessible from outside the Docker container
EXPOSE 8080

# Specify the command to run when the Docker container starts
CMD [ "npm", "run", "start"]

Each line in this Dockerfile performs a specific task:

• FROM node:14-alpine3.12: This line tells Docker to use the node:14-alpine3.12 image as the base image for our Docker image.
• WORKDIR /usr/src/app: This sets the working directory inside the Docker image to /usr/src/app.
• COPY package*.json ./: This copies the package.json and package-lock.json (if present) from your local directory to the Docker image.
• RUN npm install: This runs the npm install command to install the dependencies defined in package.json.
• COPY . .: This copies the rest of your application code into the Docker image.
• EXPOSE 8080: This tells Docker to expose port 8080 of the Docker container.
• CMD [ "npm", "run", "start"]: This is the command that will be run when the Docker container starts.

Once you have a Dockerfile, you can use the docker build command to build a Docker image from it. Then, you can use the docker run command to start a Docker container from your image.

Dockerfile Commands

Here are some common Dockerfile commands you can use:

• FROM: This command initializes a new build stage and sets the base image for subsequent instructions. For example, FROM ubuntu sets the base image as Ubuntu.
• WORKDIR: Workdir in Dockerfile sets the working directory for any instructions that follow in the Dockerfile. For example, WORKDIR /app sets the working directory to /app.
• COPY: Copy in Dockerfile copies new files or directories from <src> and adds them to the filesystem of the container at the path <dest>. For example, COPY . . copies all files and directories from the current directory on the host to the current directory in the image.
• RUN: This command executes any commands in a new layer on top of the current image and commits the results. The committed image will be used for the next step in the Dockerfile. For example, RUN apt-get update && apt-get install -y curl updates the package lists for upgrades and new packages, and then installs curl.
• CMD: Cmd in Dockerfile provides defaults for an executing container. These defaults can include an executable, or they can omit the executable, in which case you must specify an ENTRYPOINT instruction. For example, CMD ["executable","param1","param2"] provides defaults for an executing container.
• ENTRYPOINT: Entrypoint in Dockerfile allows you to configure a container that will run as an executable. For example, ENTRYPOINT ["executable", "param1", "param2"] allows you to configure a container that will run as an executable.
• EXPOSE: This command informs Docker that the container listens on the specified network ports at runtime. For example, EXPOSE 8080 informs Docker that the container listens on port 8080 at runtime.
• VOLUME: The VOLUME in Dockerfile is used to create a mount point with the specified name and marks it as holding externally mounted volumes from native host or other containers. It can be used to store persistent data generated by and used by Docker containers. For example, VOLUME /opt/app/data creates a mount point at the /opt/app/data path in the container. When a container is started from this image, Docker will mount a volume at this location.
• ENV: This command sets the environment variable <key> to the value <value>. This value will be in the environment for all subsequent instructions in the build stage and can be replaced inline in many as well. For example, ENV MY_NAME="John Doe" sets the environment variable MY_NAME to "John Doe".
• ADD: This command copies new files, directories or remote file URLs from <src> and adds them to the filesystem of the image at the path <dest>. For example, ADD <http://example.com/big.tar.xz> /usr/src/things/ downloads a tarball from the internet and extracts it in the image.

These commands form the basis of writing a Dockerfile. Each command creates a new layer in the image, so ordering the commands properly can lead to smaller image sizes.

How to Create a Dockerfile?

Creating a Dockerfile involves several steps:

1. Select the Base Image: Use the FROM instruction to specify the base image for your Docker image. This could be an official image from Docker Hub, or a custom image you've created. For example, if you're creating a JavaScript application, you might use the official Node.js image:

FROM node:14-alpine3.12

2. Set the Working Directory: Use the WORKDIR instruction to set the working directory for any subsequent instructions in the Dockerfile. All the actions (like copying files or running commands) will be performed in this directory:

WORKDIR /usr/src/app

3. Copy Files: Use the COPY instruction to copy files from your local directory into the Docker image. For example, you might copy your application's package.json and package-lock.json files:

COPY package*.json ./

4. Install Dependencies: Use the RUN instruction to install any dependencies your application needs. For a Node.js application, you might use npm to install your dependencies:

RUN npm install

5. Bundle Your Application: Use the COPY instruction again to copy the rest of your application code into the Docker image:

COPY . .

6. Expose Ports: Use the EXPOSE instruction to tell Docker which ports your application listens on:

EXPOSE 8080

7. Specify the Startup Command: Finally, use the CMD instruction to specify the command that should be run when a container is started from your image:

CMD [ "npm", "run", "start"]

Create a Docker Image from the Dockerfile

Creating a Docker image from a Dockerfile involves a few simple steps:

1. Navigate to the directory containing the Dockerfile: Use the cd command to navigate to the directory where your Dockerfile is located. For instance, if your Dockerfile is in a directory called MyDockerImages, you would use the command:

cd MyDockerImages

2. Build the Docker image: Use the docker build command followed by the t option (which allows you to tag the image with a name) and a period . to indicate that Docker should look for the Dockerfile in the current directory. For example:

docker build -t my_first_image .

This command tells Docker to build an image using the Dockerfile in the current directory and tag the resulting image with the name my_first_image.

3. Verify the Docker image was created: Use the docker images command to see a list of all Docker images on your system. You should see my_first_image in the list:

docker images

Remember, the Dockerfile should be in the directory where you run the docker build command, unless you specify a different path after the -t option. Also, ensure that you have the necessary permissions to run Docker commands. If you encounter a permission error, try prefixing the command with sudo.

How to Run a Dockerfile?

Use the docker run command followed by the --detach option to start a Docker container from your image in detached mode (running in the background). For example:

docker run --detach my_first_image

This command tells Docker to start a container from the my_first_image image.

Dockerfile Environment Variables

Environment variables in Docker are a way to externalize configuration, allowing you to customize the behavior of your Docker containers without hardcoding values into your Dockerfile or application code. There are two main types of environment variables in Docker: ARG and ENV.

• ARG variables are used to pass values during the build process. They are not available to the running container and are not inherited by containers created from the image. They are typically used to control aspects of the image creation, like setting the version of a software component to install.
• ENV variables, on the other hand, are available to the running container and can be overridden when starting a container. They are often used to set configuration options for the application running inside the container, like database connection strings or API keys.

Here's an example of how you might use ARG and ENV variables in a Dockerfile:

# Use an ARG variable to set the version of Node.js to install
ARG NODE_VERSION=14

# Use the ARG variable to set an ENV variable
ENV NODE_VERSION=${NODE_VERSION}

# Rest of your Dockerfile...

In this example, you could override the NODE_VERSION when building the image by using the --build-arg option with the docker build command:

docker build --build-arg NODE_VERSION=16 -t my_image .

This would cause Docker to install Node.js version 16 instead of the default version specified in the Dockerfile.

Conclusion

In conclusion, a Dockerfile is a text document that contains a series of commands to automate the process of creating a Docker image. It's a script of instructions that Docker reads to build an image automatically. Dockerfiles consist of specific commands that guide you on how to build a specific Docker image. These commands are written in a domain-specific language, known as the Dockerfile syntax.

The creation of a Dockerfile involves selecting a base image, setting the working directory, copying files, installing dependencies, bundling your application, exposing ports, and specifying the startup command. Once you have a Dockerfile, you can use the docker build command to build a Docker image from it. Then, you can use the docker run command to start a Docker container from your image.

Dockerfile commands include FROM, WORKDIR, COPY, RUN, CMD, ENTRYPOINT, EXPOSE, VOLUME, ENV, and ADD. Each command creates a new layer in the image, so ordering the commands properly can lead to smaller image sizes.

Environment variables in Docker are a way to externalize configuration, allowing you to customize the behavior of your Docker containers without hardcoding values into your Dockerfile or application code. There are two main types of environment variables in Docker: ARG and ENV.

Key Takeaways

1. Dockerfile Purpose: A Dockerfile is a script-like document that contains instructions for building a Docker image automatically. It specifies the steps to assemble an image, including selecting a base image, setting up the environment, copying files, installing dependencies, and defining runtime behavior.

2. Syntax and Structure: Dockerfiles use a specific syntax with instructions like FROM, WORKDIR, COPY, RUN, CMD, etc. These instructions are executed sequentially to create layers in the Docker image. Proper structuring of Dockerfiles is crucial for efficient image builds and smaller image sizes.

3. Example Dockerfile: A simple example Dockerfile for a Node.js application was provided. It showcased the use of commands like FROM to choose a base image, WORKDIR to set the working directory, COPY to copy files, RUN to install dependencies, EXPOSE to specify exposed ports, and CMD to set the startup command.

4. Environment Variables in Dockerfiles: Dockerfiles can use environment variables, both during the build process (ARG) and within the running container (ENV). These variables add flexibility, allowing users to customize image creation or configure the application running inside the container.

5. Building and Running Docker Images: To create a Docker image from a Dockerfile, the docker build command is used. The resulting image can be tagged for easy reference. To run a container from the built image, the docker run command is employed, and the container can be customized further using environment variables.