Have you ever struggled to get your application to run smoothly across different environments, from your local laptop to a production server? It's a common challenge in software development.
Fortunately, there’s a solution to this challenge — containerization.
With containerization, you can package your application and all its dependencies into a self-contained unit, called a container. You can then deploy this container on any computer with a container runtime (a piece of software) installed. No need to worry about dependency conflicts or operating system differences. Instead, you can focus on writing code and building great products.
In this blog post, I'll show you how to run a Docker image as a container, so you can start taking advantage of containerization in your own projects.
Want a quick Docker containerization guide? Check out this video.
But before we dive into the details, let's establish a common understanding of the terms "image" and "container".
What Is a Docker Image?
In simple terms, a Docker image is a package that includes everything - application code, libraries, dependencies, and the runtime environment - needed to run an application.
To better understand what a Docker image is, you can think of it as a blueprint for a container. Just like a blueprint provides a set of instructions for how to construct a building, a Docker image provides a set of instructions for how to create a container.
Once you have a Docker image, you can use it to create one or more Docker containers that house the application.
So, what are containers?
What Is a Container?
An image is a static file that serves as a blueprint for creating a container. A container is a running instance of an image.
Think of it like a recipe for a cake — the recipe tells you what ingredients you need and how to combine them to make the cake, but it's not the same thing as the cake itself. Similarly, an image tells you what software and dependencies are needed to run an application, but it's not the same thing as the running application itself.
When you create a container from an image, any application that is included in the image runs inside the container. The container provides an isolated environment for the application to run in. This means you can be confident that the application will run the same way regardless of the environment it's deployed in.
Now that we have a better understanding of what Docker images and containers are, let's move on to the next step — learning how to create a container from a Docker image.
Prerequisites for Running a Docker Image
To run a Docker image, use KodeKloud’s Docker Playground. The advantage? You don't have to set up anything. With one click, you get almost instant access to a Docker environment accessible in your web browser.
Alternatively, you can use Docker Desktop. If you don’t have Docker Desktop, make sure to download and install it on your system first. You can find the official installation guide by following this link.
3 Ways to a Run Docker Image
#1 Run a Docker Image in Attached Mode
You can run a Docker image as a container using the following command:
docker run <image-name-or-image-id>
Let’s understand the different parts of this command:
- docker: This is the command-line interface (CLI) for interacting with the Docker daemon.
- run: This is the actual command you want to execute.
- <image-name-or-image-id>: This is the name or ID of the image that you want to run as a container.
Note that the command runs the container in the foreground and attaches the terminal to the container. We run a container in attached mode when developing an application and want to view its logs.
Now that we understand the different parts of the "docker run <image-name-or-image-id>" command, let's run an "nginx" image. Go ahead and execute the following command on your terminal:
docker run nginx
You should see an output similar to this: