For enquiries call:



HomeBlogDevOpsDocker Images Command with Examples

Docker Images Command with Examples

05th Sep, 2023
view count loader
Read it in
10 Mins
In this article
    Docker Images Command with Examples

    Docker images play a pivotal role in the Docker ecosystem. In this article, we will cover an in-depth overview of Docker images, Docker hub and Docker images command. If you are looking for an in-depth course on Docker, do check the Docker course online.

    As defined by Docker’s official documentation, “Docker provides the ability to package and run an application in a loosely isolated environment called a container. The isolation and security allow us to run many containers simultaneously on a given host. Containers are lightweight because they do not need the extra load of a hypervisor but run directly within the host machine’s kernel. This means we can run more containers on a hardware combination than virtual machines.”

    What is a Docker Image?

    Before we learn about containers, we need to first understand the ‘image’ term in Docker. If we look at the diagram above, the top layer of apps and libs/bins above the Docker daemon is encapsulated in the container. The app is packaged with libraries and binaries required by it. But how does Docker achieve this packaging?

    Docker provides the facility to create a custom image on top of the Linux kernel with your app and its libraries. If we take this from an object-oriented programming point of view, an image is a class, where all the requirements are defined and declared. A container is an instance of the image. These images are stored somewhere in the cloud and pulled as needed.

    List of Docker Image Commands

    Docker uses a set of keywords to carry out these activities related to image and the list below shows all Docker image commands with their descriptions.

    docker image buildBuild an image from a Dockerfile
    docker image historyShow the history of an image
    docker image importImport the contents from a tarball to create a filesystem image
    docker image inspectDisplay detailed information on one or more images
    docker image loadLoad an image from a tar archive or STDIN
    docker image lsList images
    docker image pruneRemove unused images
    docker image pullPull an image or a repository from a registry
    docker image pushPush an image or a repository to a registry
    docker image rmRemove one or more images
    docker image saveSave one or more images to a tar archive (streamed to STDOUT by default)
    docker image tagCreate a tag TARGET_IMAGE that refers to SOURCE_IMAGE

    If you are interested in mastering DevOps and Docker in particular, do check out the best online courses for DevOps for detailed information.

    Docker Image Commands: Examples

    Build an image from a Dockerfile 
    Docker image build -t <image_name> . 

    Assuming aDockerfileis in the current directory:

    Docker image build -t myimage .

    The option-tallows you to tag the image. In this case, the image namedmyimageis taggedlatestas no tag was specified. The tag can be specified as:

    Docker image build -t myimage:first . 

    The period at the end of the command is essential. It references the application path. You can also use-f <file>if you didn’t name your build file “Dockerfile”, e.g., if an alternative file name was used:

    Docker image build -f mybuildfile.txt -t myimage . 

    Tag a built image

    Docker tag <image_name> [user/repository:tag] 

    Example: tag themyimageimage withfirstin the Docker Hubmyrepositoryrepository and the username ismyname:

    Docker tag myimagemyname/myrepository:first 

    You do not need to make the Docker Hub explicitly. Running this command will create a repository namedmyrepositoryitself.

    Push tagged images to Docker Hub

    Docker push [user/repository] 


    Dockerpush  myname/myrepository 

    You can also push with tag:

    Dockerpush  myname/myrepository:first 
    • List Docker images
    • Docker image ls
    • Docker images
    • View all images, both active and dangling:
    Docker image ls -a 


    • We have a simple Dockerfile and another file named mybuildfile.txt in our directory. The process is as follows:
    • Build an image from Dockerfile named myimage.
    • Build an image from mybuildfile.txt named mybuildimage.
    • Add the latest tag to any of the images built above. The repository name should be helloworld.
    • View the images tagged and built.
    • Push the tagged image(s).
    • Verify on your Docker Hub account  that the image(s) has been pushed

    Dockerfile Commands

    • The FROM instruction in a Dockerfile specifies the base image for the new image you will build. It is usually the first instruction in a Dockerfile and a best practice is to use images from official repos on this line.
    • The RUN instruction in a Dockerfile allows you to run commands inside the image. Each RUN instruction creates a single new layer.
    • The COPY instruction in a Dockerfile adds files into the image as a new layer. It is common to use the COPY instruction to copy your application code into an image.
    • The EXPOSE instruction in a Dockerfile documents the network port that the application uses.
    • The ENTRYPOINT instruction in a Dockerfile sets the default application to run when the image is started as a container.

    Other Dockerfile instructions include LABEL, ENV, ONBUILD, HEALTHCHECK, CMD, and more.

    Docker hub Commands

    Log into Docker Hub

    Docker login 

    Or login to another registry:

    Docker login <url> 
    Docker login -u <id> -p <password> <url> 

    Search Docker Hub

    Search the Docker Hub image repository:

    Docker search [options] <keyword> 

    Example: find up to five Docker Hub images that referencephpordered by stars rating:

    Docker search --limit 5 php 

    Pull a Docker Hub image

    Download one or more images from Docker Hub:

    Docker pull <image> 

    Example: pull the latest Node.js Long-Term-Support Alpine Linux image:

    Docker pull node:lts-alpine 

    Docker Image Use Cases

    Listing Locally Stored Docker Images

    The below command is used to list the locally stored Docker images, d:

    Docker image list

    The below command is used to list Docker images along with the long image ID

    $ Docker image list --no-trunc 

    Listing Docker Intermediary or Bad Images

    The below command is used to list all the unused Docker images on your Docker host:

    $ Docker image list --filter dangling=true 

    Below command is used to list only the image IDs of the unused Docker images on our Docker host,

    $Docker image list--quiet--filterdangling=true 

    Listing Only Docker Image IDs

    Below command is used to list only image IDs on Docker, we have to use the “Docker images” command with the “–quiet” option to suppress all other columns.

    $ Docker images --quiet 
    $ Docker images -q 

    Anatomy of a Docker Image

    Docker image is made up of a collection of files that bundle together all the essentials – such asinstallations,application code, anddependencies– required to configure a fully operational container environment. You can create a Docker image by using one of two methods:

    • Interactive: By running a container from an existing Docker image, manually changing that container environment through a series of live steps, and saving the resulting state as a new image.
    • Dockerfile: By constructing a plain-text file, known as aDockerfile, which provides the specifications for creating a Docker image.

    Docker and Kubernetes go hand in hand and are the most sought-out tech stack in DevOps space. If you are looking to enhance your Docker and Kubernetes, do check Kubernetes and Docker training.

    Docker Image Repositories

    We store images in centralized places calledimage registries. This makes it easy to share and access them.

    The most common registry isDocker HubOther registries exist, including 3rd party registries and secure on-premises registries. However, the Docker client is opinionated and defaults to using Docker Hub. We will be using Docker Hub for henceforth.

    The output of the following command is snipped, but you can see that Docker is configured to use as its default registry when pushing and pulling images (this redirects to v2).

    Docker Hub has the concept of official repositories and unofficial repositories.

    As the name suggests, official repositories are the home to images that have been vetted and curated by Docker, Inc. This means they should contain up-to-date and high-quality code that is secure, well-documented, and in line with best practices.

    Unofficial repositories can be like the wild west. You should not assume they are safe, well-documented, or built according to the best practices. That is not saying everything in unofficial repositories is bad. You just need to be very careful before trusting the code. To be honest, you should always be careful when trusting software from the internet, even images from official repositories.

    How to Create a Docker Image?

    Prerequisite: ensure Docker is installed in your local system.

    A Docker image is created using the Dockerfile and Docker command utilities. 

    The Dockerfile file contains a set of instructions for the Docker to create the container. 

    Let us create a basic image for a container that displays a “hello knowledgehut” message when it is run. 

    FROM debian:11 
    CMD ["echo", "hello knowledgehut "] 

    To create an image from theDockerfile file, we need to run the build command.

    Docker build -thello_KH 

    The Docker build command just created an image named hello_KH. The image is stored locally in the system, 1

    Docker run --rm hello 

    What is a DockerFile?

    A Dockerfile is the starting point for creating a container image. It describes an application and tells Docker how to build it into an image.

    The directory containing the application and dependencies is referred to as the build context. It is a common practice to keep your Dockerfile in the root directory of the build context. It is also important that Dockerfile starts with a capital “D” and is one word. “dockerfile” and “Docker file” are not valid.

    Do not underestimate the impact of the Dockerfile as a form of documentation. It is a great document to bridge the gap between development and operation. It also has the power to speed up the onboarding of new developers, etc. The file accurately describes the application and its dependencies in an easy-to-read format. You should treat it like you would treat source code and check it into a version control system.

    What is a Docker Container?

    Container: A container is an instance of an image, which simulates the required environment with the use of the Linux kernel packaged in it. In the diagram, we can see app B is enclosed in one container. Similarly, we can enclose the other two apps as well.

    We might ask, how a container provides the required environment with isolation if it shares the OS kernel. Well, that is done with the help of images.

    Let us take an example here. If your app only needs Python 3.5 from the system, it is only needed in your production environment as a dependency. Everything else will be an extra overhead. Docker provides the template built on the Linux kernel with only the needed dependencies, and nothing is installed in that template. That template is called an image.

    If we fetch a Python 3.5 image from Docker and run an instance of it, we can do whatever we were able to do in the host machine using a command line interface. The container can be deleted, and a new container can be created from an existing image in case of any mistake. This way, your main environment remains intact in the form of an image, and we can play around with the dependencies packaged in the image using containers.


    Docker provides a great means of managing fundamental system components, such as the operating system and the application server. Moreover, Docker makes it easier to create replica environments for your applications. Finally, you can package up to two million lines of application code into a single Docker image—so it is an increasingly popular tool in the DevOps toolkit.

    Frequently Asked Questions (FAQs)

    1What is Docker images command?

    Docker images command used to give detailed descriptions images in the system.

    2How do I view images in Docker?

    With Docker images. command you can view and manipulate the images in the system. 

    3How do I run a Docker image from the command line?

    With Docker run <image_name> command you can view the images in the system. 

    4How do I run a Docker image locally?

    By modifying the Docker environment variables 

    For example: 

    Setting below environments to ensure the Docker image runs locally 

    set userprofile = <USER_PROFILE_PATH>  # set your user proile 
    set Docker_cert_path = <DOCKER_CERT_PATH> # set Docker certification path 
    set Docker_host= <IP_ADDRESS> # use your ip and start it 
    set Docker_machine_name = <DOCKER_MACHINE_NAME> # set Docker machine name 
    set Docker_tls_verify= 1 # verify TLS connection  

    DhineshSunder Ganapathi


    DhineshSunder Ganapathi is an experienced Software Engineer in Data-Platform, Data Integrations, and Backend Technologies with a demonstrated history of working in the information technology and services industry. He has a prolific knowledge of Python, Flask, FASTAPI, Mysql, Airflow, AWS, Docker, REST APIs, Shell-scripting, and Distributed Systems. In addition, Dhinesh is a budding author, a tech blogger, a chess evangelist, and a candid toastmaster.

    Share This Article
    Ready to Master the Skills that Drive Your Career?

    Avail your free 1:1 mentorship session.

    Your Message (Optional)

    Upcoming DevOps Batches & Dates

    NameDateFeeKnow more
    Course advisor icon
    Course Advisor
    Whatsapp/Chat icon