What are containers used for?

You’ve heard of Docker containers, and you have maybe run one or two yourself.

But now, you’re at the stage where you’re wondering what the practical uses for Docker containers are.

Beyond docker run redis, what are containers really used for?

Containers are used as a way of packaging and running an application, and its dependencies, in an isolated, predictable and repeatable way.

Virtual machines can do the same things, but they take more time to create, configure, ship, and run. The advantage of the container is that it has all of these benefits, but it’s much faster and more lightweight.

Benefits of containers

Before we look at the main use cases for Docker containers, it’s a good idea to revisit the characteristics of containers.

Understanding the benefits of containers, helps us to understand why they are great for the different use cases we’ll look at further below.

Containers offer the following characteristics:

  • Repeatability: A container image will run the same way, wherever it is run. So once my application is built as a Docker image, I can run multiple instances of my application very easily, and they will all behave in the same way. Or, I can run my container wherever Docker is installed.

  • Portability: With Docker, portability comes from the Docker image format. It’s like a zip file (actually it’s a TAR archive) containing my whole application and all of its dependencies. I can pull Docker images from public or private registries, or create my own.

    In addition, Docker images are comprised of several stacked layers, which saves time when moving images around, as Docker only fetches the layers which it doesn’t already have stored locally.

  • Isolation: A Docker container offers a certain level of isolation. This means that my application runs in its own sealed environment, and cannot affect other applications when it is running inside a container, unless I choose to allow it.

Virtual machines also have the same benefits that we’ve seen above, but a container offers a thinner level of virtualisation. It doesn’t virtualise an entire operating system, it just virtualises a process. This means that containers have a couple of additional benefits:

  • Lightweight: Because containers virtualise a single process, they are lightweight and more easily distributed than a virtual machine.

  • Composable: Since containers are lightweight, they can be easily stacked together and swapped around. This is especially useful in microservice architectures, which are made up of many self-contained services, which are independently managed and maintained. Containers are a really good technology to achieve this.

Use cases for containers

So bearing in mind the characteristics of containers, what are some practical use cases for Docker?

With any new technology, it’s good to understand the reasons why it exists, and find some practical applications. The concepts become easier to grasp when you understand what they’re used for.

So let’s see the main places where you might see containers being used in the real world.

#1 - Setting up a development environment

A lot of people get started with containers by using Docker while they’re developing software. People use Docker to run one or more of their application’s dependencies.

Often, we waste a lot of time installing and configuring the dependencies that we need for our application. Most applications depend on some other component to run – such as a database.

This often requires downloading and configuring a database to use in development. How many times have you needed a database, when developing an app?

I’ve spent a lot of time in the past, installing and configuring complex bits of software – such as Oracle database – just for the purposes of doing a few days of development. That time is often wasted, because you need it for a short amount of time, and you remove the database when it’s no longer needed.

But if your application uses a dependency which has been packaged into a Docker container, then you can simply pull the Docker image from a registry, run the container, and you have an instance of your dependency, ready to use immediately.

#2 - Building and compiling software

If you’re developing software, you might need to compile it. This is especially the case for languages like Java or C. That might be a simple task, but the dependencies needed to compile your program often run into many hundreds of megabytes, and take time to configure properly.

Construction hard hats hanging on a shipping container
Building software with containers
(Freepik/Rawpixel)

With Docker, this can be made a lot easier. Some people use containers as a way of creating a repeatable build environment, containing all of the build-time dependencies.

When this environment is packaged as a Docker image, it is highly predictable and easy to consume. And, more importantly, it means that you can run a build in a clean container whenever you like, avoiding the problem of having to clean up afterwards.

#3 - Running an application in different environments

This is another example of how Docker is used when developing software. Once you have built a Docker image of your application, it will run in the same way in any environment.

This is made possible because of the standard API provided by container engines like Docker. A container will run predictably on my machine, just in the same way as it does on any other machine.

Starting a container is usually a simple matter of using the docker run command.

This means that containers are a useful way to ship applications between different environments, while maintaining parity between them. In other words, the same application can be run in all environments, by just building one container image, and running it in each environment, with slightly different configuration.

Even if containers aren’t used to run an application in production, they can still be a really valuable way of sharing an application between different environments (e.g. dev, test, UAT) in a predictable way.

#4 - Deploying to a platform-as-a-service

Containers are often used as a unit of deployment on a platform as a service, like Kubernetes, OpenShift or AWS.

This is great for both platform admins and developers, because now there is one standard packaging format for building and running apps on the platform.

Admins don’t need to learn dozens of different types of application servers and operating systems, and developers don’t need to understand a whole range of virtualisation technologies.

This is why platforms-as-a-service have consolidated on containers and Docker.

The real benefit as a developer is that I can package up my application, and everything it needs to run, in a very well-known, portable format. When my application package arrives on the platform, the administrators know how to run it, because it is using the Docker (or OCI) standard.

In the past, this was hard, because applications used to be deployed in many different ways, via scripts, installers, or even on a VM. But containers offer a universal approach that is understood by both developers and system administrators.

This is similar in concept to how applications run on the Apple and Android app stores. Developers package their application in a standard way, and then cell phones know how to unpack and run those applications, because they use a standard format.

#5 - Running third-party programs, apps and utilities

Up until now, I’ve covered ways in which containers are used in software development. But, the thing is, containers have really helpful, practical uses when running third-party software too.

Even if you’re not a software developer, you can still make use of containers. Docker isn’t just limited to use as a tool for coders.

Many popular applications are now available in containerised form. You might find that an application which you use regularly is available as a Docker image, which you can pull from one of the public registries.

Again, the benefit is that the application is packaged in a standard way, includes all of its dependencies, and runs very predictably, wherever it is run. Except this time, you save all the hassle of having to figure out how to install the application, or set it up manually.

Summary

So, let’s just review. Containers are often used for:

  • Running your application’s dependencies - this is especially useful if you’re a developer and you want to set up a development environment quickly.

  • Creating repeatable, predictable build environments - you can compile your own programs inside a Docker container

  • Moving applications between environments - the Docker image is a very portable format for shipping an application between dev, test and production environments.

  • Packaging and deploying an application on a platform-as-a-service - PaaS platforms like Kubernetes, OpenShift and AWS now enable you to run Docker containers in the cloud.

  • Running utilities or programs so you don’t have to install and configure everything upfront

There are, of course, many more uses for containers. But there is something that ties all of these use cases together: the characteristics of containers, like portability, isolation and repeatability.

I hope you get inspired by seeing these examples of how people are using containers in the real world. It’s a great time to be in software development and I’m excited to see the new use cases that people will come up with for containers.

Happy containerising!