Sign in to unlock

Get unlimited access to all questions and answers


Get lifetime access


Track progress


Save time

55 Docker interview questions and answers for software engineers

Docker is a set of platform as a service products that use OS-level virtualization to deliver software in packages called containers. Here is a list of coding interview questions on Docker to help you get ready for your next data structures interview in 2021.
  • 1.

    What is Docker, and how is it different from virtual machines?


    Docker is a containerization platform that simplifies application deployment by ensuring software and its dependencies run uniformly on any infrastructure, from laptops to servers to the cloud.

    Using Docker allows you tobundle code and dependencies into a container image you can then run on any Docker-compatible environment. This approach is a significant improvement over traditional virtual machines, which are less efficient and come with higher overheads.

    Key Docker Components

    • Docker Daemon: A persistent background process that manages and executes containers.
    • Docker Engine: The CLI and API for interacting with the daemon.
    • Docker Registry: A repository for Docker images.

    Core Building Blocks

    • Dockerfile: A text document containing commands that assemble a container image.
    • Image: A standalone, executable package containing everything required to run a piece of software.
    • Container: A runtime instance of an image.

    Virtual Machines vs. Docker Containers

    Virtual Machines

    • Advantages:

      • Isolation: VMs run separate operating systems, providing strict application isolation.
    • Inefficiencies:

      • Resource Overhead: Each VM requires its operating system, consuming RAM, storage, and CPU. Running multiple VMs can lead to redundant resource use.
      • Slow Boot Times: Booting a VM involves starting an entire OS, slowing down deployment.


    • Efficiencies:

      • Resource Optimizations: As containers share the host OS kernel, they are exceptionally lightweight, requiring minimal RAM and storage.
      • Rapid Deployment: Containers start almost instantaneously, accelerating both development and production.
    • Isolation Caveats:

      • Application-Level Isolation: While Docker ensures the separation of containers from the host and other containers, it relies on the host OS for underlying resources.

    Code Example: Dockerfile

    Here is the Dockerfile:

    FROM python:3.8
    WORKDIR /app
    COPY requirements.txt requirements.txt
    RUN pip install --no-cache-dir -r requirements.txt
    COPY . .
    CMD ["python", ""]

    Core Unique Features of Docker

    • Layered File System: Docker images are composed of layers, each representing a set of file changes. This structure aids in minimizing image size and optimizing builds.

    • Container Orchestration: Technologies such as Kubernetes and Docker Swarm enable the management of clusters of containers, providing features like load balancing, scaling, and automated rollouts and rollbacks.

    • Interoperability: Docker containers are portable, running consistently across diverse environments. Additionally, Docker complements numerous other tools and platforms, including Jenkins for CI/CD pipelines and AWS for cloud services.

  • 2.

    In practice, how do you reduce the size of Docker images?


    Reducing Docker image sizes is crucial for efficient resource deployment. You can achieve this through various strategies.

    Multi-Stage Builds

    Multi-Stage Builds allow you to use multiple Dockerfile stages, segregating different aspects of your build process. This enables a cleaner separation between build-time and run-time libraries, ultimately leading to smaller images.

    Here is the dockerfile with the multi-stage build.

    # Use an official Node.js runtime as the base image
    FROM node:current-slim AS build
    # Set the working directory in the container
    WORKDIR /app
    # Copy the package.json and package-lock.json files to the workspace
    COPY package*.json ./
    # Install app dependencies
    RUN npm install
    # Copy the entire project into the container
    COPY . .
    # Build the app
    RUN npm run build
    # Use a smaller base image for the final stage
    FROM node:alpine AS runtime
    # Set the working directory in the container
    WORKDIR /app
    # Copy built files and dependency manifest
    COPY --from=build /app/package*.json ./
    COPY --from=build /app/dist ./dist
    # Install production dependencies
    RUN npm install --only=production
    # Specify the command to start the app
    CMD ["node", "dist/main.js"]

    The --from flag in the COPY and RUN instructions is key here, as it allows you to select artifacts from a previous build stage.

    .dockerignore File

    Similar to .gitignore, the .dockerignore file excludes files and folders from the Docker build context. This can significantly reduce the size of your build context, leading to slimmer images.

    Here is an example of a .dockerignore file:


    Using Smaller Base Images

    Selecting a minimalistic base image can lead to significantly smaller containers. For node.js, you can choose a smaller base image such as node:alpine, especially for production use. The alpine version is particularly lightweight as it's built on the Alpine Linux distribution.

    Here are images with different sizes:

    • node:current-slim (about 200MB)
    • node:alpine (about 90MB)
    • node:current (about 900MB)

    One-Time Execution Commands

    Using RUN and multi-line COPY commands within the same Dockerfile layer can lead to image bloat. To mitigate this, leverage a single RUN command that packages multiple operations. This approach reduces additional layer creation, resulting in smaller images.

    Here is an example:

    RUN apt-get update && apt-get install -y nginx && apt-get clean

    Ensure that you always combine such commands in a single RUN instruction, separated by logical operators like &&, and clean up any temporary files or caches to keep the layer minimal.

    Package Managers and Caching

    When using package managers like npm and pip in your images, it's important to use a --production flag.

    For npm, running the following command prevents the installation of development dependencies:

    RUN npm install --only=production

    For pip, you can achieve the same with:

    RUN pip install --no-cache-dir -r requirements.txt

    This practice significantly reduces the image size by only including necessary runtime dependencies.

    Utilize Glob Patterns for COPY

    When using the COPY command in your Dockerfile, it's best to introduce .dockerignore syntax to ensure only essential files are copied.

    Here is an example:

    COPY ["*.json", "*.sh", "config/", "./"]
  • 3.

    Can you explain what a Docker image is?


    A Docker image is a lightweight, standalone, and executable software package that includes everything needed to run a piece of software, including the code, a runtime, libraries, environment variables, and configuration files.

    It provides consistency across environments by ensuring that each instance of an image is identical, a key principle of Docker's build-once-run-anywhere philosophy.

    Image vs. Container

    • Image: A static package that encompasses everything the application requires to run.
    • Container: An operating instance of an image, running as a process on the host machine.

    Layered File System

    Docker images comprise multiple layers, each representing a distinct file system modification. Layers are read-only, and the final container layer is read/write, which allows for efficiency and flexibility.

    Key Components

    • Operating System: Traditional images have a full or bespoke OS tailored for the application's needs. Recent developments like "distroless" images, however, focus solely on application dependencies.
    • Application Code: Your code and files, which are specified during the image build.

    Image Registries

    Images are stored in Docker image registries like Docker Hub, which provides a central location for image management and sharing. You can download existing images, modify them, and upload the modified versions, allowing teams to collaborate efficiently.

    How to Build an Image

    1. Dockerfile: Describes the steps and actions required to set up the image, from selecting the base OS to copying the application code.
    2. Build Command: Docker's build command uses the Dockerfile as a blueprint to create the image.

    Advantages of Docker Images

    • Portability: Docker images ensure consistent behavior across different environments, from development to production.
    • Reproducibility: If you're using the same image, you can expect the same application behavior.
    • Efficiency: The layered filesystem reduces redundancy and accelerates deployment.
    • Security: Distinct layers permit granular security control.

    Code Example: Dockerfile

    Here is the Dockerfile:

    # Use a base image
    FROM ubuntu:latest
    # Set the working directory
    WORKDIR /app
    # Copy the current directory contents into the container at /app
    COPY . /app
    # Specify the command to run on container start
    CMD ["/bin/bash"]

    Best Practices for Dockerfiles

    • Use the official base image if possible.
    • Aim for minimal layers for better efficiency.
    • Regularly update the base image to ensure security and feature updates.
    • Reduce the number of packages installed to minimize security risks.
  • 4.

    How does a Docker container differ from a Docker image?


    Docker images serve as templates for containers, whereas Docker containers are running instances of those images.

    Key Distinctions

    • State: Containers encapsulate both the application code and its runtime environment in a stable and consistent state. In contrast, images are passive and don't change once created.

    • Mutable vs Immutable: Containers, like any running process, can modify their state. In contrast, images are immutable and do not change once built.

    • Disk Usage: Containers have both writable layers (such as logs or configuration files) and read-only layers (the image layers), potentially leading to increased disk usage over time. Docker's use of layered storage, however, limits this growth.

      Images, on the other hand, are solely read-only, meaning each instance based on the same image doesn't consume additional disk space.

    Visual Aids

    Docker Image vs Container
    Here is an image for Docker Image vs Container.

    Practical Demonstration

    Here is the code:

    1. Dockerfile - Defines the image:
    # Set the base image
    FROM python:3.8
    # Set the working directory
    WORKDIR /app
    # Copy the current directory contents into the container at /app
    COPY . /app
    # Install any needed packages specified in requirements.txt
    RUN pip install --trusted-host -r requirements.txt
    # Make port 80 available to the world outside this container
    EXPOSE 80
    # Define environment variable
    ENV NAME World
    # Run when the container launches
    CMD ["python", ""]
    1. Building an Image - Use the docker build command to create the image.
    docker build -t myapp .
    1. Instantiating Containers - Run the built image with docker run to spawn a container.
    # Run a single command within a new container
    docker run myapp python
    # Run a container in detached mode and enter it to explore the environment
    docker run -d -it --name mycontainer myapp /bin/bash
    1. Viewing Containers - The docker container ls or docker ps commands display active containers.

    2. Modifying Containers - As an example, you can change the content of a container by entering in via docker exec.

    docker exec -it mycontainer /bin/bash
    1. Stopping and Removing Containers - This can be done using the docker stop and docker rm commands or combined with the -f flag.
    docker stop mycontainer
    docker rm mycontainer
    1. Cleaning Up Images - Remove any unused images to save storage space.
    docker image prune -a
  • 5.

    What is the Docker Hub, and what is it used for?


    The Docker Hub is a public cloud-based registry for Docker images. It's a central hub where you can find, manage, and share your Docker container images. Essentially, it is a version control system for Docker containers.

    Key Functions

    • Image Storage: As a centralized repository, the Hub stores your Docker images, making them easily accessible.

    • Versioning: It maintains a record of different versions of your images, enabling you to revert to previous iterations if necessary.

    • Collaboration: It's a collaborative platform where multiple developers can work on a project, each contributing to and pulling from the same image.

    • Link to GitHub: Docker Hub integrates with the popular code-hosting platform GitHub, allowing you to automatically build images using pre-defined build contexts.

    • Automation: With automated builds, you can rest assured that your images are up-to-date and built to the latest specifications.

    • Webhooks: These enable you to trigger external actions, like CI/CD pipelines, when certain events occur, enhancing the automation capabilities of your workflow.

    • Security Scanning: Docker Hub includes security features to safeguard your containerized applications. It can scan your images for vulnerabilities and security concerns.

    Cost and Pricing

    • Free Tier: Offers one private repository and unlimited public repositories.
    • Pro and Team Tiers: Both come with advanced features. The Team tier provides collaboration capabilities for organizations.

    Use Cases

    • Public Repositories: These are ideal for sharing your open-source applications with the community. Docker Hub is home to a multitude of public repositories, each extending the functionality of Docker.

    • Private Repositories: For situations requiring confidentiality, or to ensure compliance in regulated environments, Docker Hub allows you to maintain private repositories.

    Key Benefits and Limitations

    • Benefits:

      • Centralized Container Distribution
      • Security Features
      • Integration with CI/CD Tools
      • Multi-Architecture Support
    • Limitations:

      • Limited Private Repositories in the Free Plan
      • Might Require Additional Security Measures for Sensitive Workloads
  • 6.

    Explain the Dockerfile and its significance in Docker.


    One of the defining features of Docker is its use of Dockerfiles to automate the creation of container images. A Dockerfile is a text document that contains all the commands a user could call on the command line to assemble an image.

    Common Commands

    • FROM: Sets the base image for subsequent build stages.
    • RUN: Executes commands within the image and then commits the changes.
    • EXPOSE: Informs Docker that the container listens on a specific port.
    • ENV: Sets environment variables.
    • ADD/COPY: Adds files from the build context into the image.
    • CMD/ENTRYPOINT: Specifies what command to run when the container starts.

    Multi-Stage Builds

    • FROM: Allows for multiple build stages in a single Dockerfile.
    • COPY --from=source: Enables copying from another build stage, useful for extracting build artifacts.

    Image Caching

    Docker uses caching to speed up build processes. If a layer changes, Docker rebuilds it and all those that depend on it. Often, this results in fortuitous cache misses, making builds slower than anticipated.

    To optimize, place commands that change frequently (such as file copying or package installation) toward the end of the file.

    Docker Build Accesses a remote repository, the Docker Cloud. The build context is the absolute path or URL to the directory containing the Dockerfile.

    Tips for Writing Efficient Dockerfiles

    • Use Specific Base Images: Start from the most lightweight, appropriate image to keep your build lean.
    • Combine Commands: Chaining commands with && (where viable) reduces layer count, enhancing efficiency.
    • Remove Unneeded Files: Eliminate files your application doesn't require, especially temporary build files or cached resources.

    Code Example: Dockerfile for a Node.js Web Server

    Here is the Dockerfile:

    # Use a specific version of Node.js as the base
    FROM node:14-alpine
    # Set the working directory in the container
    WORKDIR /app
    # Copy package.json and package-lock.json first to leverage caching when the
    # dependencies haven't changed
    COPY package*.json ./
    # Install NPM dependencies
    RUN npm install --only=production
    # Copy the rest of the application files
    COPY . .
    # Expose port 3000
    EXPOSE 3000
    # Start the Node.js application
    CMD ["node", "app.js"]
  • 7.

    How does Docker use layers to build images?


    Docker follows a Layered File System approach, employing Union File Systems like AUFS, OverlayFS, and Device Mapper to stack image layers.

    This structure enhances modularity, storage efficiency, and image-building speed. It also offers read-only layers for image consistency and integrity.

    Union File Systems

    Union File Systems permit stacking multiple directories or file systems, presenting them coherently as a single unit. While several such systems are in use, AUFS and OverlayFS are notably popular.

    1. AUFS: A front-runner for a long time, AUFS offers versatile compatibility but is not part of the Linux kernel.
    2. OverlayFS: Now integrated into the Linux kernel, OverlayFS is lightweight and provides backward compatibility with ext4 and XFS.

    Image Layering in Docker

    When stacking Docker image layers, it's akin to a file system with read-only layers superimposed by a writable layer, the container layer. This setup ensures separation and persistence:

    1. Base Image Layer: This is the foundation, often comprising the operating system and core utilities. It's mostly read-only to safeguard uniformity.

    2. Intermediate Layers: These are interchangeable and encapsulate discrete modifications. Consequently, they are also mostly read-only.

    3. Topmost or Container Layer: This layer records real-time alterations made within the container and is mutable.

    Code Overlayers

    Here is the code:

    1. Each layer is defined by a Dockerfile instruction.
    2. The base image is ubuntu:latest, and the application code is stored in a file named
    # Layer 1: Start from base image
    FROM ubuntu:latest
    # Layer 2: Set the working directory
    WORKDIR /app
    # Layer 3: Copy the application code
    COPY /app
    # Placeholder for Dockerfile
    # ...
  • 8.

    What's the difference between the COPY and ADD commands in a Dockerfile?


    Let's look at the subtle distinctions between the COPY and ADD commands within a Dockerfile.


    • COPY: Designed for straightforward file and directory copying. It's the preferred choice for most use-cases.
    • ADD: Offers additional features such as URI support. However, since it's more powerful, it's often recommended to stick with COPY unless you specifically need the extra capabilities.

    Key Distinctions

    • URI and TAR Extraction: Only ADD allows you to use URIs (including HTTP URLs) as well as automatically extract local .tar resources. For simple file transfers, COPY is the appropriate choice.
    • Cache Considerations: Unlike COPY, which respects image build cache, ADD bypasses cache for any resources that differ even slightly from their cache entries. This can lead to slower builds.
    • Security Implications: Since ADD permits downloading files at build-time, it introduces a potential security risk point. In scenarios where the URL isn't controlled, and the file isn't carefully validated, prefer COPY.
    • File Ownership: While both COPY and ADD maintain file ownership and permissions during the build process, there might be OS-specific deviations. Consistent behavior is often a critical consideration, making COPY the safer choice.
    • Simplicity and Transparency: Using COPY exclusively, when possible, ensures clarity and simplifies Dockerfile management. For instance, it's easier for another developer or a CI/CD system to comprehend a straightforward COPY command than to ascertain the intricate details of an ADD command that incorporates URL-based file retrieval or TAR extraction.

    Best Practices

    • Avoid Web-Based Transfers: Steer clear of resource retrieval from untrusted URLs within Dockerfiles. It's safer to copy these resources into your build context, ensuring security and reproducibility.

    • Cache Management: Because ADD can bypass caching for resources that are even minimally different from their cached versions, it can inadvertently lead to slowed build processes. To avoid this, prefer the deterministic, cache-friendly behavior of COPY whenever plausible.

  • 9.

    What’s the purpose of the .dockerignore file?


    The .dockerignore file, much like gitignore, is a list of patterns indicating which files and directories should be excluded from image builds.

    Using this file, you can optimize the build context, which is the set of files and directories sent to the Docker daemon for image creation.

    By excluding unnecessary files, such as build or data files, you can reduce the build duration and optimize the size of the final Docker image. This is important for minimizing container footprint and enhancing overall Docker efficiency.

  • 10.

    How would you go about creating a Docker image from an existing container?


    Let's look at each of the two main methods:

    docker container commit Method:

    For simple use cases or quick image creation, this method can be ideal.

    It uses the following command:

    docker container commit <CONTAINER_ID> <REPOSITORY:TAG>

    Here's a detailed example:

    Say you have a running container derived from the ubuntu image and nicknamed 'my-ubuntu'.

    1. Start the container:

      docker run --interactive --tty --name my-ubuntu ubuntu
    2. For instance, you decide to customize the my-ubuntu container by adding a package.

    3. Make the package change (for this example):

      docker exec -it my-ubuntu bash  # Enter the shell of your 'my-ubuntu' container
      apt update
      apt install -y neofetch         # Install `neofetch` or another package for illustration
      exit                           # Exit the container's shell
    4. Take note of the "Container ID" using docker ps command:

      docker ps

      You will see output resembling:

      CONTAINER ID        IMAGE               COMMAND             ...        NAMES
      f2cb54bf4059        ubuntu              "/bin/bash"         ...        my-ubuntu

      In this output, "f2cb54bf4059" is the Container ID for 'my-ubuntu'.

    5. Use the docker container commit command to create a new image based on changes in the 'my-ubuntu' container:

      docker container commit f2cb54bf4059 my-ubuntu:with-neofetch

      Now, you have a modified image based on your updated container. You can verify it by running:

      docker run --rm -it my-ubuntu:with-neofetch neofetch

    Here, "f2cb54bf4059" is the Container ID that you can find using docker ps.

    Image Build Process Method:

    This method provides more control, especially in intricate scenarios. It generally involves a two-step process where you start by creating a Dockerfile and then build the image using docker build.


    1. Create A Dockerfile: Begin by preparing a Dockerfile that includes all your customizations and adjustments.

    For our 'my-ubuntu' example, the Dockerfile can be as simple as:

    FROM my-ubuntu:latest
    RUN apt update && apt install -y neofetch
    1. Build the Image: Enter the directory where your Dockerfile resides and start the build using the following command:

      docker build -t my-ubuntu:with-neofetch .

    Subsequently, you can run a container using this new image and verify your modifications:

    docker run --rm -it my-ubuntu:with-neofetch neofetch


11 Reactive Systems interview questions and answers for software engineers

Reactive systems are an architectural style that allows multiple individual applications to blend into one unit, reacting to their environment, while staying aware of each other. Here is a list of coding interview questions on Reactive Systems to help you get ready for your next data struc...

. Reactive Systems
34 Microservices interview questions and answers for software engineers

Microservice architecture – a variant of the service-oriented architecture structural style – arranges an application as a collection of loosely coupled services. In a microservices architecture, services are fine-grained and the protocols are lightweight. Here is a list of coding intervie...

. Microservices
7 Layering & Middleware interview questions for developers

Middleware in the context of distributed applications is software that provides services beyond those provided by the operating system to enable the various components of a distributed system to communicate and manage data. Middleware supports and simplifies complex distributed application...

. Layering & Middleware
55 Docker interview questions and answers for software engineers

Docker is a set of platform as a service products that use OS-level virtualization to deliver software in packages called containers. Here is a list of coding interview questions on Docker to help you get ready for your next data structures interview in 2021.

. Docker
23 Databases interview questions and answers for software engineers

A database is an organized collection of data, generally stored and accessed electronically from a computer system. Where databases are more complex they are often developed using formal design and modeling techniques. Here is a list of coding interview questions on Databases to help you g...

. Databases
21 Concurrency interview questions and answers for software engineers

In computer science, concurrency is the ability of different parts or units of a program, algorithm, or problem to be executed out-of-order or in partial order, without affecting the final outcome. Here is a list of coding interview questions on Concurrency to help you get ready for your n...

. Concurrency
13 CAP Theorem interview questions and answers for software engineers

In theoretical computer science, the CAP theorem, also named Brewer's theorem after computer scientist Eric Brewer, states that it is impossible for a distributed data store to simultaneously provide more than two out of the following three guarantees: Consistency: Every read receives the ...

. CAP Theorem
18 Caching interview questions and answers for software engineers

Caching is a technique that stores a copy of a given resource and serves it back when requested. Here is a list of coding interview questions on Caching to help you get ready for your next data structures interview in 2021.

. Caching
Load more posts
folder icon

Access all answers

Get the inside track on what to expect in your next tech interview. We offer you a collection of high quality technical interview questions to help you prepare for your next coding interview.

graph icon

Track progress

A smart interface helps you track your progress and focus on the topics you need. You can search through questions and sort them by type.

clock icon

Save time

Save tens of hours searching for information on hundreds of low-quality sites designed to drive traffic and make money from advertising.

Land a six-figure job at one of the top tech companies.

amazon logo meta logo google logo microsoft logo openai logo
Ready to nail your next interview?

Stand out and get your dream job