Author: RunCloud Team

When Solomon Hykes founded dotCloud in 2008, his ambitions were quite different. The company, a Y Combinator Summer 2010 graduate, eventually pivoted in 2013, relaunching as Docker.

Hykes took to the stage at PyCon in 2013, releasing the first demo for Docker. During that first talk, Hykes explained that Docker was simply the underlying technology that powered dotCloud and that the company was pivoting towards an open-source model.

It didn’t take long for Docker to attract attention from industry heavyweights like IBM, Red Hat, and Microsoft. With a Docker container, you could develop software in a portable environment.

Docker allowed developers to deploy, replicate, and easily port images to simplify workflows and introduce a level of flexibility that was simply not possible at the time.

There are several key components that combine to help you perform functions using Docker, and the image is just one of them. Apart from that, there’s the basic Docker client and the Docker daemon, both of which are required to make images work.

But, what is a Docker image? How do you use it? Here’s everything you need to know.

What is a Docker Image?

A Docker image is simply a read-only file that’s used to run code within a Docker container. Think of it as a template that contains all the instructions needed to run the code. All of the code and dependencies are packaged in one file.

The Docker image contains all of the tools, packages, libraries, and source code required to run the software. These instructions can be used to build Docker containers, often containing multiple layers, with each one originating from the previous layer.

Docker images can be deployed on any host, and they are reusable, allowing developers to take images from one project and use them in another, saving them considerable time and effort. 

Related: What is Docker And How Does it Work

Anatomy of a Docker Image

Layers are offshoots of instructions from the Dockerfiles stored in your local image cache. The local image cache forms the base for subsequent images you want to create. In general, some of the components of Docker images are listed below.

1. Base image

This helps you build Docker images from scratch. Base images give you control of all other Docker images. You can build a base image using the FROM scratch directive in the Dockerfile. Some examples of base images include Debian, Ubuntu, Redhat, and Alpine.

2. Parent image 

They’re the building block of Docker images. The FROM directive in the Dockerfile is used to create the parent image. In most cases, Dockerfiles are built from a parent image.

3. Layers

Also called “image layers”, these are the intermediate images that form Docker images. Through the layers, you can cache every step you take while creating Docker images. Layers also increase the reusability and the speed of creating Docker images.

Layers are set in a hierarchical form, and each layer depends on the one preceding it. This is why it’s essential to keep layers susceptible to changes as high as possible in the stack list. Because should you change any layer, Docker will rebuild the specific layer and the preceding layers around it.

4. Container layer

This is the modifiable layer of a Docker image. It saves the changes you make to containers during operations.

5. Docker manifest

This provides information about Docker images in JSON format. To perform actions on manifest, you need to use either the “single manifest” or “manifest list” commands. Specifically, the single manifest describes the size, layers, operating system (OS), and architecture of a Docker image.

A manifest list – also called “multi-arch image” or “fat manifest” – helps you group multiple images. After creating the list, you can use the group name of your list instead of the individual name of your image. This means you can use the docker pull or docker run command to pull desired Docker images.

Docker Images vs. Containers

Before we proceed further, it’s important to understand the differences between a Docker image and a container. A container is a self-contained space that lets you run an application.

Docker containers are completely isolated, so they don’t affect the system, and the environment they run in can’t affect the software either. A Docker image, on the other hand, runs the code within a container.

A Docker image can exist outside of a container, but a container will need to execute an image for it to have something to “contain”. Therefore, a container is fully dependent on a Docker image to execute an application.

Think of an image as a template, so while it can exist independently, you can’t execute it. It’s important to mention that a container is just an executed image. As you build a container, it automatically creates another layer on top of the image, letting you modify the container layer (images are read-only).

This also means that with the help of a single image base, you can easily create multiple Docker images. Over time, you’ll have images that contain different layers, with each iteration slightly similar to the previous one.

How to Build Docker Images

Primarily, Dockerfiles are used to build Docker images. Dockerfiles contain the commands you need to build and customize Docker images. Every instruction you execute with Dockerfiles creates an intermediate layer.

To create a Docker image, your first step would be to create a Dockerfile. Docker uses the Dockerfile to build images, so all instructions must be stored there. It’s a simple text file where you can add all the commands needed to create an image.

To write one, you can use the simple Express application generator. Creating a basic Node.js app is a good way to start. Express application generator is a CLI (command-line interface) that lets you create basic app skeletons.

If you’re on Linux, just fire up the Terminal, and install the generator using the following commands:

$ npm install express-generator -g
$ express docker-app
$ npm install
$ npm start

Once installed, head to the root directory (where you saved the application) and create a simple text file. You can name it whatever you want, but let’s go with “Dockerfile”.

Now, to create an image using this file, run the following commands:

# Filename: Dockerfile
FROM node:14-alpine
WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install
COPY . .
$ docker build .

Docker will now build the image. To check whether the image was created, you can run the docker images command.

Once you build a Dockerfile, you don’t need to rebuild an image manually. The table below contains the basic Dockerfile commands you need to build images.

To build Docker images from Dockerfiles, follow these steps:

• Create your Dockerfiles: Here, you need to create a new file and directory for your Docker image. 
• Run Docker build to build your Docker image. The build command uses instructions from specific files in a directory to build a Docker image. 
• After creating the Docker image, use the Docker run command to create your container. 

Alternatively, you can use the interactive method to manually build Docker images from preexisting images. To do this, follow these steps:

• Open a terminal session after installing Docker. 
• Use the Docker run command image_name:tag_name to start an interactive shell session with the container specified by the command. But there’s a caveat: Docker will automatically pull the most recent image version if you omit the tag name. If the images aren’t on any local file, Docker will build the container using resources from the Docker hub.

The interactive method is fast and easy to use, especially if you’re a newbie developer. But it can make you create unnecessary layers and multiple unoptimized images.

In contrast, the Dockerfile approach is more flexible and easily integrates the continuous integration/continuous delivery (CI/CD) process. The Dockerfile approach is your go-to method if you’re looking to build enterprise-grade containers.

You also have the option of exporting or loading your images through the save command. To download the image you just exported on another machine, you can then use the load command.

And, if you want to run your Docker image, you can use the following command:

$ docker run -i -t Dockerfile /bin/bash

You can replace the name with that of your image if you’ve renamed it.

How to Use Docker Images

Docker containers are the main use of Docker images. Images contain everything you need to create, deploy, and run your applications in a container. By extension, containers fly applications in different environments efficiently, especially microservice-based apps,.

Improved CI/CD efficiency is another major use of Docker images. CI/CD is an automation principle used to integrate software changes. It uses a single repository to automate software development processes (building, testing, and deployment).

Docker uses caching, the process of storing Docker image layers, to improve the CI/CD process. By storing every layer, caching increases the speed of creating lightweight Docker images. Lightweight images with a short build time make it fast and easy to deploy applications in different environments.

While you can build a Docker image from scratch, as shown above, most developers prefer to pull images from different repositories. The Docker Hub has an extensive range of images available.

You can then use the image base to create different Docker images too. But, it’s important to understand that there’s also the parent image, which is different from the base image.

A base image is the empty container image, which you can use to eventually build an image from the ground up if you want. Parent images are pre-built images that offer some core functionality.

For instance, a basic Linux system image or an image of WordPress might be considered a parent image. All the images that you find on Docker Hub are also parent images.

How to Maximize Docker Image Security

The images that you use to build the container obviously play an important role in ensuring the overall safety of the container itself. In case the image is infected, the container will be too.

It’s important to take certain security precautions when using Docker images. Here are some key points to keep in mind.

Only Use Verified and Signed Images

There are numerous third-party image repositories available, but ideally, you should steer clear of them. Instead, always use verified images from the Docker Hub to maintain project integrity.

Furthermore, it’s important that you only use signed images to mitigate your risk. In case someone tampered with the image, you’ll know right away.

Use Minimal Images with No Unnecessary Libraries

Instead of using images that have several layers and contain various components that you won’t need, try to avoid downloading images that install additional system libraries that you won’t require. This can help you reduce your overall exposure.

Define a Privileged User

It’s important that you specify a USER for each Dockerfile. If you don’t, the container will run with root privileges on the host machine. That exposes your container to severe security issues and can lead to hackers eventually hacking into the host machine.

Regularly Check Images for Vulnerabilities

It’s important to note that vulnerabilities might be introduced as you continue to build new layers. While you may have checked the image originally, and verified it, make it a habit to check it regularly to identify issues and fix them at the earliest.

After Action Report – Working with Docker Images

Docker images are great because they are so lightweight and flexible. Interested in learning more? Join the conversation by commenting below, or send us a Tweet about how Docker has simplified software development for you!

Docker is commonly used by software developers and engineers to develop, test, and control the conditions in which they test their software. It allows software developers to create portable containers, making it easy to collaborate with others remotely.

If you’re new to Docker, learning all of the commands may seem a bit daunting at first. The sheer amount of documentation available for Docker can be overwhelming to review. However, there are some commands which are more commonly used than others.

What is Docker?

Docker is a free, open-source platform that lets developers create, manage, and run containers in the cloud or on servers. It’s considered a PaaS (platform-as-a-service) product that lets developers use virtualization to run software in containers.

Docker makes it easy for developers to use system resources more efficiently, as containerized apps generally use less memory when compared with virtual machines. Docker also makes applications portable, since a container includes everything the application requires to work.

You just need Docker runtime on a host to easily execute a Docker container. Now that you know the basics, let’s look at 20 essential Docker commands.

20 Essential Docker Commands and What They Do

Here are 20 essential Docker commands, including their intended functions. 

1. Docker run

The Docker run command is used to create and start containers. When you run this command, it’s going to first look for a container image.

If one is not found, it will create a new one and run it.

Docker run[OPTIONS] IMAGE [COMMAND] [ARG...]

Here’s an example of running a Nginx container from Docker’s repository.

docker run —-name nginx-root -p 8080:80 -d nginx

The -d means that the container will run in the background detached, while you can also customize the name flag and map the container port to the host port.

2. Docker search

You can use this command to search for different images from the main Docker hub. It will show you information about the image, including its name, description, and other specifications.

Here’s an example:

docker search nginx

3. Docker stop

This command is used to stop containers that you’re running. Unlike the docker kill command, this one stops the container in its own time. Here’s how to use it:

docker stop [container name or ID]

4. Docker rename

This one’s fairly self-explanatory. If you want to rename a container, you can use this command. Here’s the syntax:

docker rename [current_name] [new_name]

5. Docker restart

If you’ve stopped a container, you can restart it using this command. The syntax is as follows:

docker restart [container name]

6. Docker pause or unpause

This command lets you pause or suspend all processes running within a container. Here’s the syntax that you use:

docker pause [container name]

You can also unpause containers using the unpause command:

docker unpause [container name]

7. Docker kill

This command can be used to send the “KILL” signal to a container. It sends a SIGKILL signal without sending a request for termination.

Generally, this command is in typical emergency situations, which is why it’s generally a wise idea to use the docker stop command before trying this.

docker kill [container name]

8. Docker pull

The docker pull command can be used to pull an image from the Docker Hub. Here’s the basic syntax:

docker pull [container name]

You can also use tags to identify images, including the -all-tags- command to pull all images from a repository.

9. Docker ps

If you want to list all containers that are running in the background, you can use this command. Here’s the syntax:

docker ps—-all

10. Docker login

If you want to log into the Docker hub, you can use this command. When you use this command, you’ll have to enter your Docker hub credentials.

docker login

11. Docker commit

You can use this command to save an image of a container or create one on a localized system.

docker commit [container name]

12. Docker exec

You can use this to execute new commands in a container that is already running.

docker run --name ubuntu_1 --rm -i -t ubuntu bash

This will create a new container entitled ubuntu_1 and launch a Bash session.

13. Docker rmi

If you want to remove an image from the host node and free up some space you can use this command. You will have to add the image ID to run this command.

docker rmi [add image ID]

14. Docker cp

This command is used to copy files and directories from the container to the host and vice versa.

docker cp test-container:/1/2/random.conf ./test

This command is going to copy the random.conf file from the test-container and then paste it into the test directory, which would ideally be present in the same directory.

15. Docker logs

If you want to check the logs for all Docker containers, you can use this command. This is great when you want to review errors and then resolve problems. Here’s the syntax for it:

docker logs [container name or ID]

16. Docker info

This is a fairly simple command that will show you information about the localhost, or the host on which Docker is running. The syntax is fairly simple:

docker info

17. Docker logout

As you can imagine, this command will log you out of the Docker hub. The syntax is straightforward:

docker logout

18. Docker inspect

If you want some basic information about the images and the containers, such as the checksum, layers, or the container’s IP address, you can use this command.

The syntax for this is as follows:

docker inspect [image name]

19. Docker history

If you want to go through the history of any image on your Docker system, you can use this command to get all the information you require.

This can help you identify any changes made to the image, as well as any commits, starting from the most recent one. Here’s the syntax:

docker history [container name]

20. Docker push

This command is used to upload a Docker image to a particular repository or the Docker hub. Here’s the syntax for it:

docker push [image ID]

After Action Report – Which Commands Do You Use Most Frequently?

There are hundreds of different Docker commands and thousands of variations in total. Which Docker commands do you use most frequently? Let us know & join the conversation in the comments (or by Tweeting @RunCloud_io) what your preferred server file management process currently looks like! 💬

Docker is an incredibly popular platform & framework that lets users build, run, and manage different “containers” on cloud servers. For app developers, Docker is an excellent option as it significantly accelerates their workflow, while offering them a comprehensive array of tools and environments to seamlessly execute each project.

In this article, we aren’t going to discuss what Docker is or how it really works, since if you want to create a Docker image for an application, you already know the basics. Instead, we’re going to look at the steps that you can take to create a Docker image for an application.

So, without further ado – let’s dive right in…

What Does It Mean To Build A Docker Image?

Building an image in Docker simply means creating a Dockerfile, hosting your Docker image on a registry, and then pulling and running the image on the same or another machine.

How To Create Docker Image for Your Application

Here is the recommended workflow that you should follow if you want to create a Docker image for your application.

1. Write Your Dockerfile

Docker usually takes instructions from the Dockerfile in order to build images. It automatically reads the instructions to build the file. Essentially, a Dockerfile is a text file that includes all relevant commands required to create an image.

For the purposes of this tutorial, we’ll just create a simple Node.js app through the Express application generator. The first step is to use the Express generator, a command-line interface that’s used for creating Express application skeletons.

This guide is written for users on a Linux machine, and those who are adept at using a command-line interface. Open the Terminal, and install the Express app generator with the following code:

$ npm install express-generator -g
$ express docker-app
$ npm install
$ npm start

For Windows users, use the Command Prompt:

> set DEBUG=myapp:* & npm start

And, if you’re on Mac, just do the following:

$ DEBUG=myapp:* npm start

After having installed the package dependencies, then go ahead and launch the application. If you type http://localhost:3000, you’ll see the original “Welcome to Express” text on your screen, indicating confirmation. 

So, you have an application running already, but the Dockerfile is still missing. Open your application’s root directory, and create a file. Name it “Dockerfile”.

The Dockerfile usually begins through a base image. This is the part where your image is based. To create one, here’s what you do:

# Filename: Docker
FROM node: 14-alpineges

2. Building Your Docker Image

Now, you need to send instructions to Docker to copy the source when you run the docker build command. For this, use the following command:

# Filename: Dockerfile
FROM node:14-alpine
WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install
COPY . .

Now that you have the Dockerfile ready, it’s time to build the image. Run the following command:

$ docker build .

Docker will build the image, and you can also view the image you built using the docker images command:

$ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
<none> <none> 7y312abd0bf2 1 minute ago 80.2MB

3. Host Your Docker Image

Once you have created the image, the next step is to share it on a registry so that it can be downloaded and used on any machine. The DockerHub registry is free to use, and you can easily push or pull images through there very easily.

But, if you don’t want your images to be publicly available, you can also host them on a private cloud server. Private repos are available from Docker, or you can just sign up for a cloud server through any IaaS provider like DigitalOcean, Linode, or AWS.

4. Save and Load Images from Files

Now, you can easily export and load Docker images as files using a simple command:

$ docker save Dockerfile 

If you want to download your Docker image on any destination machine, use the following code:

$ docker load Dockerfile

You can also use any other name except “Dockerfile” to save your images.

How To Run a Docker Image

If you’ve given the Docker image a name, you can just launch it using the code below:

$ docker run -i -t Dockerfile /bin/bash

After Action Report — Is Docker Useful?

In essence, it really depends. After this, you should be able to create your own Docker image for a simple Node.js app.

As you can see, Docker is generally a wise option if you need to port your applications quite often and access them from multiple machines. If your software development is generally restricted, Docker might not be a suitable choice.

But, for distributed software teams, there’s hardly a better choice than Docker since it speeds up development and helps in containerizing different versions of the same application.