Why use Containers?

Use cases for containers

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

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

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

Running third-party applications and utilities

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

Here are some examples of applications that you find on Docker Hub, one of the main registries where you can find and download Docker images:

• PostgreSQL (a database)

• Python (the programming language)

• Ubuntu (Linux operating system)

• Nginx (web server)

The benefits are that the application is packaged in a standard way, includes all of its dependencies, and runs very predictably, wherever it is run. You save all the hassle of having to figure out how to install the application, or set it up manually.

Deploying software to a cloud platform

Containers are supported by cloud platforms, like AWS, Kubernetes and OpenShift.

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

Administrators don’t need to learn the intricacies of different types of application servers and their libraries, and developers don’t need to understand a whole range of virtualisation technologies.

This is why platforms-as-a-service have generally all adopted containers, and Docker.

The real benefit, as a developer, is that you can package up an application, and everything it needs to run, in a very well-known, portable format, the container image. When your image 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 difficult, because applications used to be deployed in many different ways, via scripts, installers, or even on a VM. But containers have a standard API, which 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 the cellphone OS knows how to unpack and run those applications, because they use a standard format.

Running dependencies during development and testing

Many 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, or perhaps an API.

How many times have you needed to access a database, when developing an app? It often requires downloading the dependency and configuring it. The setup time is significant. We can spend a lot of time installing and configuring these complex bits of software – e.g. Oracle Database – just for a few days of actual development time.

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

Compiling software predictably

If you’re developing software, you will probably need to compile or package it. This is especially the case for languages like Java or C. It might seem like a simple task, but the tools you need to compile your program can run into many hundreds of megabytes, and take time to configure properly.

With containers, this process is much easier.

Firstly you create your build environment in a container image. This contains all of your build-time dependencies. Then, when you want to build your software, you can mount your code into the build container, and compile your code. Because each build runs in a fresh instance of the same build container, your builds should run much more predictably.

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.