Unraveling Docker: Key Concepts of Docker Files and Registries

Unraveling Docker: Key Concepts of Docker Files and Registries

In our previous blog post, we delved into the Docker engine and Dockerfiles. If you missed that article, I highly recommend checking it out before continuing with this one. In this blog post, we'll provide a brief overview and correction of the concepts covered in the previous post.

The Docker engine, the core of the Docker platform, enables the creation and management of lightweight, isolated environments for running applications. These containers are crucial for modern software development and deployment, offering consistency and portability across different environments.

Today's blog is about Dockerfiles and Docker registries.


"Dockerfiles are a set of instructions that define how a Docker image should be built. They serve as a blueprint for creating containerized applications. Dockerfiles are written in a simple and human-readable format, making it easy for developers to define the environment and dependencies required for their applications."

A Dockerfile is a container that includes

  • Base image

  • Instructions

  • Working directory

  • Exposing ports

  • Comments

  • COPY or ADD

  • ENV

  • RUN

  • USER


  • ARG

Base Image: Typically, a Dockerfile begins with the specification of a base image, which acts as the basis for your container. You can, for example, choose a simple Linux distribution such as Alpine or a more feature-rich one such as Ubuntu.

Instructions: Dockerfiles are made up of a set of instructions that are performed in order. These steps may include transferring files into the image, installing software packages, configuring environment variables, and other activities.

Working Directory: Within the container, you may provide a working directory where commands and files should be executed and stored.

Exposing Ports: If your application requires particular ports to be available, you can use the 'EXPOSE' instruction to make those ports available.

Comments: Dockerfiles are primarily instructions, but they should include comments to explain their purpose, starting with a # symbol, for better documentation and understanding of the Dockerfile's logic.

 # Use a base image
 FROM ubuntu:20.04

 # Install necessary packages
 RUN apt-get update && apt-get install -y python3

 # Set the working directory

 # Expose port 80

 # Define the command to run when the container starts
 CMD ["python3", "app.py"]

COPY or ADD: The 'COPY' or 'ADD' commands enable the transfer of files or directories from your local machine to the container, enabling the inclusion of application code, configuration files, and other assets.

# Copy application code into the container
COPY . /app

ENV: The ENV instruction enables setting environment variables within a container, which is crucial for configuring application settings and providing information to scripts and processes.

# Set environment variable
ENV APP_ENV=production

RUN: The RUN command is utilized during the image build process to execute commands for installing dependencies, running build scripts, or configuring the image environment.

# Install software using package manager
RUN apt-get update && apt-get install -y software-package

USER: The USER instruction allows you to specify the user or UID for running commands within a container, thereby enhancing security by restricting processes to non-root users.

# Create a non-root user
RUN useradd -ms /bin/bash myuser

# Switch to the non-root user
USER myuser

VOLUME: The VOLUME instruction creates a mount point for external volumes, enabling data persistence outside the container, commonly used for storing databases or logs that can survive container restarts.

 # Create a volume mount point
 VOLUME /data

ARG: The ARG instruction enables the transfer of build-time arguments to the Dockerfile, thereby enhancing its flexibility and customization.

# Define a build-time argument

# Use the argument in the Dockerfile

CMD or ENTRYPOINT: These instructions provide the command that should be executed when the container starts. You can use 'CMD' to provide the command and its parameters, or 'ENTRYPOINT' to create an entry point script.

# Use an official Node.js runtime as the base image
FROM node:14

# Set the working directory inside the container

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

# Install project dependencies
RUN npm install

# Copy the rest of the application source code to the container
COPY . .

# Specify the command to run the application
CMD ["node", "app.js"]

After preparing a Dockerfile, the docker build command may be used to generate an image from it.

docker build -t my-node-app .

Example 1: Docker file official Python runtime as the base image

# Use an official Python runtime as the base image
FROM python:3.9

# Set the working directory inside the container

# Copy the current directory contents into the container at /app
COPY . /app

# Install any needed packages specified in requirements.txt
RUN pip install -r requirements.txt

# Define the default command to run when the container starts
CMD ["python", "app.py"]9
  • FROM: Specifies the base image, in this case, Python 3.9.

  • WORKDIR: Sets the working directory within the container to /app.

  • COPY: Copies the local files and directories into the container.

  • RUN: Installs Python dependencies defined in requirements.txt.

  • CMD: Specifies the default command to run the Python application when a container is started.

A docker file is used to create a container, specify a base image, instructions, and working directory, and enable or disable specific ports. The 'EXPOSE' instruction allows for port listening, and the 'CMD' or 'ENTRYPOINT' instructions define the command to be executed when the container starts.

Docker Registries: Sharing and Managing Images

Docker registries are repositories where Docker images may be stored and distributed. They act as a central point for the distribution of containerized applications among teams, companies, and the larger community. Docker Hub and Docker Registry (open-source) are two of the most popular Docker registries.

How Docker Registries Work

  • Pushing Images

  • Pulling Images

  • Versioning

  • Private Registries

  • Content Trust

Pushing Images: After creating a Docker image, use the 'docker push' command to upload it to a Docker registry.

docker push my-node-app:latest

Pulling Images: After creating a Docker image, use the 'docker push' command to upload it to a Docker registry.

docker pull my-node-app:latest

Versioning: Docker images can contain many versions, which are frequently identifiable by tags. Tags like 'latest', which denotes the most current version, and version-specific tags like 'v1.0' are common.

Private Registries: Private Docker registries may be set up by organizations to host proprietary or sensitive images, ensuring control and security over their containers.

Content Trust: Docker content trust enables you to validate the validity and integrity of images downloaded from a registry, hence increasing security.

Example 2: Commands for Working with Docker Registry

docker push username/repository:tag

To retrieve an image from a private container registry such as 'myregistry.example.com,' normally follow these steps.

Authentication: You must verify your identity with the private register. This normally entails entering a login and password or supplying some kind of token. Docker Login: To authenticate with the private registry, use the 'docker login' command.

docker login myregistry.example.com

You will be required to provide your credentials (username and password or token) after running this program.

Pull the Image: Once authorized, execute the 'docker pull' command to retrieve the image from the private registry.

 docker pull myregistry.example.com/your-image-name:tag

Replace 'your-image-name' with the name of the picture to be pulled, and 'tag' with the version or tag to be used.

Run the Container: After downloading the image, you may use 'docker run' to launch a container using the image.

docker login myregistry.example.com
docker pull myregistry.example.com/your-image-name:tag
docker run myregistry.example.com/your-image-name:tag

Check that you have the appropriate permissions and credentials to access the private registry and that your Docker environment is configured correctly.

Remember to replace 'my registry.example.com', 'your-image-name', and 'tag' with the actual registry URL, image name, and tag you're working with.

Dockerfiles are crucial for building containerized applications within Docker. They provide clear instructions for defining the environment, dependencies, and behaviors. Key components include comments, COPY or ADD instructions, environment variables, RUN commands, user context, mount points, and build-time arguments. By following best practices, Dockerfiles enhances the efficiency, security, and maintainability of containerized applications. Docker registries enable image sharing across teams and organizations, making them essential for efficient application development.

Stay tuned for the upcoming articles in the series, where we'll discuss more interesting topics related to Docker. Subscribe to our channel to ensure you don't miss any part of this enlightening journey!

Thank you for reading our blog. Our top priority is your success and satisfaction. We are ready to assist with any questions or additional help.

Warm regards,

Kamilla Preeti Samuel,

Content Editor

ByteScrum Technologies Private Limited! ๐Ÿ™