Docker is a powerful containerization tool that enables developers to package their applications and their dependencies into a single unit called Docker image. The Docker image offers seamless deployment, scalability, and portability. In this article, I will make sure that you understand what is docker and guide you through the steps to create a Docker image.

What is Docker?

Docker is a tool that simplifies software packaging and deployment. It wraps application and their dependencies into compact units called containers. Docker containers share a host operating system kernel which makes them lightweight, fast, and resource-efficient. It provides a standardized way to package, distribute, and execute applications. It allows developers to create, test, and deploy applications on any operating system or cloud platform without any worry about compatibility issues or hardware requirements.

What is Docker Image?

Docker Image is a light weighted executable package, that contains all the packages, softwares, libraries that is required to run a piece of code or an application. Docker Images streamlines the deployment process with ensuring consistency across different environments and simplifyying the software distributions.

Why Create Docker Images?

Creating a Docker Images facilitates with protability, consistency and efficiency in software deployment. The following are the reasons to create a docker images:

• Portability: Docker images encapsulates the applications and dependencies and let them make portable across different environments.
• Consistency: It provides consistency in deployment and deployment by reducing comptability challenges inbetween development and production environments.
• Efficiency: Creating of docker images enhances the containerization technology for faster startup times, scalability and efficient resource utilization.

How to Create Docker Image With Dockerfile: A Step-By-Step Guide

Step 1: Creating A Dockerfile

• Firstly we have to create a file with name Dockerfile in your directory.

vim Dockerfile

• The following illustrates about creating a Dockerfile:

Step 2: Write Dockerfile Instructions

• Inside the Dockerfile write the instructions that needed for defining environment and setup needed for an application that typically includes for specifying image, copying file, installing dependencies and configuring the runtime environment.

# Use an existing base image
FROM ubuntu:latest

# Set the working directory in the container
WORKDIR /app

# Copy application files from host to container
COPY . .

# Install dependencies
RUN apt-get update && apt-get install -y \
    python3 \
    python3-pip

# Set the default command to execute when the container starts
CMD ["python3", "app.py"]

• The following screenshot specifies about defining the docker instructions:

• Here also ensure to have app.py sample python application as shown in the following:

# app.py

def main():
    print("Hello, Docker!")

if __name__ == "__main__":
    main()

• The following screenshot specifies about providing a python application:

Step 3: Build Your Docker Image

• Here, in the step build the docker image from the Dockerfile using the following command:

docker build -t myimg . 

• The following screenshot specifies about building a docker image:

Step 4: Verify The Image

• After once buildig the docker image verify it whether it is created successful or not with running following command:

docker images

• The following command specifies the successful creation of docker image:

Step 5: Test the Docker Image ( Optional )

• For the testing the docker image locally try on creating a container with that image with the following command:

docker run -d -p 8080:80 myimg

• The following screenshot specifies about the creating a container to the new build docker image:

How to Create A Base Image Using Scratch? A Step-By-Step Guide

Step 1: Prepare Your files

• Firstly prepare the files or binaries that you want to include in the creating minimal Ubuntu Image. Here the files should be essential binaries or configurations.

Step 2: Create A Root File System

• Setup a minimal root file system for Ubuntu. It typically involves creating directories such as /bin , /etc and /usr and populate them essential files and directories.

Step 3: Download Ubuntu Base Packages

• Now, try to download the base packages for Ubuntu. Here you will need to fetch the essential packages that are required for a minimal Ubuntu system. These essential packages includes libc , coreutils, apt , bash and other essential utilities.

Step 4: Install Essential Packages

• Extract the downloaded base packages into your root file system and try to configure them as necessary. Ensure that essential packages are properly installed and configured for providing a functional ubuntu environment.

Step 5: Create A Dockerfile

• Now, create a file with name “Dockerfile” in your project working directory and define the instructions in that file for building the ubuntu base image from scratch from your custom root file system. The dockerfile looks as follows:

# Use Scratch as the base image
FROM scratch

# Copy the custom root file system into the image
COPY ./rootfs /

# Set the entry point
ENTRYPOINT ["/bin/bash"]

Step 6: Build The Docker Image

• On using the following command build the docker image from the Dockerfile.

docker build -t myubuntuimage .

Step 7: Verify The Docker Image

• After the successful build, verify the docker image with executing the following command:

docker images

How to Create a Full Image Using tar?

The following are the steps to create a docker image using a tarball effectively:

Step 1: Prepare Files

• Try on gathering all the files and directories that you want ot include in Docker Image.

Step 2: Create A Tarball

• On using tar command create a tarball (.tar file) that containing your files.

tar -czf image.tar.gz .

Step 3: Create Dockerfile

• Now, a Dockerfile with specifying the instructions to load and extract the tarball into the creating docker image.

Step 4: Build the DockerImage

• Build a docker image from the dockerfile on using the following command:

docker build -t myimage .

Step 5: Verify The Docker Image

• After once successfully building the docker image, verify it by listing the docker images:

docker images

How to Optimize Your Docker Image Size?

The following are the recommended suggestions for optimizing your Docker Image size:

• Choose A Minimal Base Image: Select a light weighted base image like alpine for reducing overall docker image size.
• Minimize Layers: Each image layer adds size to the Image. To reduce it ensure to have less Image layers, by combining multi commands with one RUN instruction.
• Clean Up After Installations: Ensure to remove the unnecessary softwares and files after the installation of packages and keep the image size minimal. Using commands like `apt-get clean` or `yum clean all`.
• Use Multi-Stage Builds: On utilizing the multi-stage builds we can seperate the build environment from the runtime environment. It helps in removing unncessary

How to Host Your Docker Image?

The following steps help in hosting your docker images:

Step 1: Choose Container Registry

• Select the Container Registry like Dockerhub, Amazon ECR, Google Container Registry ( GCR ), Azure Container Registry ACR. Here we are choosing Dockerhub registry.

Step 2: Tage Your Docker Image

• Use one local image in your docker that you want to host and change the tag of that docker image as shown in the following format.

docker tag <image_tag> <registry_url>/<repository_name>:<tag>

Step 3: Login to the Registry

• Now, authenticate with the container registry using the following command and access your account:

docker login 

Step 4: Push Your Docker Image

• After successful login in, push the docker image into the docker hub with the following command:

docker push <registry_url>/<repository_name>:<tag>

Step 5: Access Your Hosted Image

• Once the docker image is successfully pushed, it will be hosted in the container registry and it can be accessed by others for deployment or sharing.

Examples of Docker Commands for Creating a Dockerfile

The following are the examples of Docker Commands for creating a Dockerfile:

1. Creating a Dockerfile

• The following command can be used for creating Dockerfile:

touch Dockerfile

2. Editing The Dockerfile

• The following command can be used for customizing or editing the Dockerfile

nano Dockerfile

3. Building Image From A Dockerfile

• The following command can be used for building Image from a Dockerfile:

docker build -t myapp .

Dockerfile vs Docker Image Vs Container

• The following are the major comparisons between with Dockerfile, Docker Image and Docker Containers:

docker images

docker pull <Docker_image>

Docker pull ngnix:latest

docker tag <image_id> <new_image_name>:<tag>

docker rmi <Image_id>

sudo systemctl start docker

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>How to create docker image</title>
</head>
<body>
    <H1>Hey geeks to create a docker image you have to write a Dockerfile and then build it using
        docker command .
    </H1>
</body>
</html>

FROM nginx:alpine
COPY index.html /usr/share/nginx/html
EXPOSE 80

docker build -t gfg-image .

docker images | grep gfg-image

docker run -d -p 80:80 gfg-image

docker run [Options]  <Container_name> <Container_Image>

docker run -dit --name mycontainer1 ubuntu:latest

docker commit <container_id> <new_img_name>

docker images 

docker tag <new_image_name> <registry_url>/<repository_name>:<tag>

docker push <registry_url>/<repository_name>:<tag>