Scribd
Upload
30 views6 pages

Docker File

This document provides a detailed guide on creating a Dockerfile, including steps to choose a base image, set up a project directory, write Dockerfile instructions, and build a Docker image. It outlines essential Dockerfile commands such as FROM, RUN, CMD, and COPY, along with examples and best practices for building and managing Docker images. Additionally, it explains the use of docker commit for creating images from container changes, while emphasizing the preference for Dockerfiles for reproducibility.

Uploaded by

Sudhakar Chillara
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
30 views6 pages

Docker File

This document provides a detailed guide on creating a Dockerfile, including steps to choose a base image, set up a project directory, write Dockerfile instructions, and build a Docker image. It outlines essential Dockerfile commands such as FROM, RUN, CMD, and COPY, along with examples and best practices for building and managing Docker images. Additionally, it explains the use of docker commit for creating images from container changes, while emphasizing the preference for Dockerfiles for reproducibility.

Uploaded by

Sudhakar Chillara
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 6

Docker File

Creating a Dockerfile is a straightforward process. You can use any text editor
or integrated development environment (IDE) to create and edit Dockerfiles.
Here’s a basic step-by-step guide to creating a Dockerfile:
Step1: Choose a Base Image
Determine which base image best suits your needs. You can find official images
on Docker Hub (https://hub.docker.com/) for common software like Ubuntu,
Alpine Linux, Python, Node.js, etc.
Choose the base image that matches the requirements of your application or
service.
Step2: Set up Your Project Directory
Create a directory for your Docker project if you haven’t already done so.
Place your application code and any other necessary files or directories within
this project directory.
Step3: Create a Dockerfile
Inside your project directory, create a new file named Dockerfile (without any
file extension).
Open the Dockerfile in a text editor or IDE.
Type vi Dockerfile and press Enter. This will open the vi editor with a new file
named Dockerfile.
Press i to enter insert mode. You can now start typing your Dockerfile contents.
Step4: Write Dockerfile Instructions
Begin your Dockerfile with the FROM instruction, specifying the base image
you selected.
Follow this with additional Dockerfile instructions to configure your image,
such as

FROM: Defines a base image, it can be pulled from docker hub


(for example- if we want to create a javascript application with node as
backend then we need to have node as a base image, so it can run node
application.)
RUN: Executes command in a new image layer( we can have multiple run
commands )
CMD: Command to be executed when running a container( It is asked to have
one CMD command, If a Dockerfile has multiple CMDs, it only applies the
instructions from the last one.
EXPOSE: Documents which ports are exposed (It is only used for
documentation)
ENV: Sets environment variables inside the image
COPY: It is used to copy your local files/directories to Docker Container.
ADD:
 It is more feature-rich version of the COPY instruction. COPY is preferred
over ADD.
 Major difference b/w ADD and COPY is that ADD allows you to copy from
URL that is the source can be URL but in COPY it can only have local ones.
ENTRYPOINT: Define a container's executable (You cannot override and
ENTRYPOINT when starting a container unless you add the --entrypoint flag.)
VOLUME: It defines which directory in an image should be treated as a volume.
The volume will be given a random name which can be found using docker
inspect command.
WORKDIR: Defines the working directory for subsequent instructions in the
Dockerfile (Important point to remember that it doesn't create a new
intermediate layer in Image)
Each instruction represents a step in the process of building your Docker image.
You can use comments (lines starting with #) to provide explanations or context
for each instruction.

Step4: Save Your Dockerfile


Once you’ve written the Dockerfile with the necessary instructions, save the
file.
Once you’re done editing, press Esc to exit insert mode.
Type :wq and press Enter to save the changes and exit vi. If you want to exit
without saving, type :q! and press Enter.
Example of a simple Dockerfile:
# This is a Dockerfile
FROM ubuntu:latest
RUN apt-get update && apt-get install -y python3
COPY . /app
WORKDIR /app
CMD ["python3", "app.py"]

This example Dockerfile installs Python 3 on an Ubuntu base image, copies the
contents of the current directory into the /app directory in the image, sets the
working directory to /app, and specifies the command to run when the container
starts.
Remember, vi is a modal editor, so you'll need to switch between insert mode (for
typing) and command mode (for saving, exiting, etc.) using the appropriate
commands (i for insert mode, Esc to exit insert mode, :wq to save and exit, :q! to
exit without saving, etc.).
Step5: Build Your Docker Image
Open a terminal or command prompt.
Navigate to your project directory using the cd command.
Run the docker build command to build your Docker image, specifying the location
of your Dockerfile and optionally providing a name and tag for the image.
docker build -t my-image-name:tag .

Replace my-image-name with the desired name for your image and tag with an
optional version or label. The dot . at the end of the command indicates the build
context (current directory).

Step 6: Verify Your Docker Image


After the build process completes, you can verify that your Docker image was
created successfully by running:
docker images

This command lists all Docker images on your system, including the one you
just built.
Step 7:Run Containers from Your Image
Once your Docker image is built, you can run containers from it using the
docker run command, specifying the image name:
docker run my-image-name

This will start a container based on your image, running the command specified
in the CMD instruction of your Dockerfile.
Step8: docker build
The docker build command is used to build a Docker image from a Dockerfile
and a context directory. Here's the basic syntax
docker build [OPTIONS] PATH

 [OPTIONS]: This is where you can specify various options to customize


the build process. Some common options include -t to tag the image
with a name and optional tag, -f to specify the name of the Dockerfile if
it's not named Dockerfile, --build-arg to pass build-time variables, and --
no-cache to build the image without using any cache.
 PATH: This is the path to the directory containing the Dockerfile and any
other files needed for the build. This directory is known as the build
context.
For example, if your Dockerfile is in the current directory, you can simply run:

docker build .

If your Dockerfile has a different name or is located in a different directory, you


can specify the path using the -f option:
docker build -f /path/to/Dockerfile .

To tag the resulting image with a name and optional tag, you can use the -t
option:
docker build -t my_image:tag .
This will tag the image as my_image with the tag tag.
You can also pass build-time arguments to the Dockerfile using the --build-arg
option:
docker build --build-arg MY_VARIABLE=value

This will pass a build-time variable named MY_VARIABLE with a value of value
to the Dockerfile.
Once the docker build command is executed, Docker will read the instructions
from the Dockerfile, execute them step by step, and create a new Docker image
based on those instructions.
Step 9: docker commit
The docker commit command is used to create a new image from the changes
made to a container. It essentially allows you to save the current state of a
container as a new image. However, it's generally recommended to use a
Dockerfile and docker build to create reproducible images, rather than relying
on docker commit.
docker commit [OPTIONS] CONTAINER [REPOSITORY[:TAG]]

 [OPTIONS]: This is where you can specify various options to customize


the commit process. Common options include -a to specify the author, -
m to add a commit message, and --change to apply Dockerfile
instructions to the image.
 CONTAINER: This is the name or ID of the container you want to commit.
 [REPOSITORY[:TAG]]: This is the name and optional tag you want to give
to the new image.
For example, to commit changes made to a container named my_container
and create a new image named my_image:latest, you would run:
docker commit my_container my_image:latest

This command creates a new image with the changes made to the
my_container container and tags it as my_image with the latest tag.

It’s important to note that while docker commit allows you to quickly create an
image from a modified container, it's generally considered best practice to use
Dockerfiles and docker build for creating reproducible and maintainable images
whenever possible.

You might also like