What is Containerization?

Containerization is a type of virtualization in which all the components of an application are bundled into a single container image and can be run in isolated user space on the same shared operating system.

Containers are lightweight, portable, and highly conducive to automation. As a result, containerization has become a cornerstone of development pipelines and application infrastructure for a variety of use cases. Understanding what containerization is, and how to implement it securely, can help your organization modernize and scale its technology stacks.

Free Trial Container Security Guide

How Does Containerization Work?

Containerization works by virtualizing all the required pieces of a specific application into a single unit.

Under the hood, that means containers include all the binaries, libraries, and configuration an app requires. However, containers do NOT include virtualized hardware or kernel resources.

Instead, containers run “on top” of a container runtime platform that abstracts the resources. Because containers just include the basic components and dependencies of an app without additional bloat, they are faster and more lightweight than alternatives like virtual machines or bare metal servers. They also make it possible to abstract away the problems related to running the same app in different environments. If you can provide the underlying container engine, you can run the containerized application.

Containerization vs Virtualization

It’s easy for the uninitiated to be confused by the difference between containerization (what containerization software like Docker enables) and traditional server virtualization (what hypervisors like HyperV and VMware ESXi enable). In simple terms, the difference boils down to this:

Server virtualization is about abstracting hardware and running an operating system. Containerization is about abstracting an operating system and running an app.

They both abstract away resources, containerization is just another level “up” from server virtualization. In fact, containerization and server virtualization aren’t mutually exclusive. You can run containerized apps on top of a container engine that is deployed within a virtual machine.

The Layers of Containerization

To get a better idea of exactly how containerization works, let’s take a closer look at how all the pieces — from hardware to the containerized application — fit together.

Hardware infrastructure: With any application, it all starts with physical compute resources somewhere. Whether those resources are your own laptop or spread across multiple cloud datacenters, they are a must-have for containers to work.
Host operating system: The next layer that sits atop the hardware layer is the host operating system. As with the hardware layer, this could be as simple as the Windows or *nix operating system running on your own computer or abstracted away completely by a cloud service provider.
Container engine: This is where things start to get interesting. Container engines run on top of your host operating system and virtualize resources for containerized apps. The simplest example of this layer is running Docker on your own computer.
Containerized apps: Containerized apps are units of code that include all the libraries, binaries, and configuration an application requires to run. A containerized application is run as an isolated process in “user space” (outside of the operating system’s kernel).

The Benefits of Containerization

Given what we know, we can see that containerization bundles only what an app needs into a single unit and allows the apps to run anywhere the container engine exists. With that in mind, it becomes easy to see the benefits of containerization which include:

Portability: One of the traditional “dev vs ops” challenges of the past was why a given app worked in one environment (e.g. staging) and not another (e.g. production). Usually, the problem was reconciled to a difference in the two environments. For example, maybe a different version of a specific dependency was installed. Containerization solves this problem because the same exact container images — which include dependencies — can be run everywhere.
Speed: Containers tend to start up in a fraction of the time virtual machines or bare metal servers take. While specific boot times will vary depending on resources and the size of an app, generally speaking containers start up in seconds while virtual machines can take minutes.
Efficiency: Because containers only include what an app needs to run, they are significantly more lightweight than virtual machines. Containers are usually megabytes in size, while virtual machines are usually gigabytes in size. As a result, containers make it possible for teams to more efficiently use server resources.
Simplicity of deployment: Because containers are portable and lightweight, they can easily be deployed almost anywhere. If you can run the underlying container engine, you can run the containerized application.
Scalability: Containerized applications start up quickly, don’t take up too much space, and are easy to deploy. As a result, containerization makes it much easier to scale your deployments. This is why containers have become a cornerstone of microservices and cloud-based applications.

Specific Containerization Use Cases

Knowing the benefits of containerization is important, but understanding real-world use cases allows you to put the knowledge into practice. Here are some examples of popular containerization use cases:

Microservices: A microservices architecture is built around the idea of many small, independent, and loosely coupled services working together. Because containers are a great way to deploy isolated units of code, they have become the de-facto standard for deploying microservices.
CI/CD: Continuous integration/continuous deployment (CI/CD) is all about testing and deploying reliable software fast. By bundling applications into portable, lightweight, and uniform units of code, containerization enables better CI/CD because containers are automation friendly, reduce dependency issues, and minimize resource consumption.
Modernizing legacy apps: Many teams are moving legacy monolithic applications to the cloud. However, in order to do so, they need to be sure the app will actually run in the cloud. In many cases, this means leveraging containerization to ensure the app can be deployed anywhere.

Kubernetes and Containers

Kubernetes, also known as K8s, is a popular tool to help scale and manage container deployments. Containerization software like Docker or LXC lacks the functionality to orchestrate larger container deployments, and K8s fills that gap. While there are other container orchestration tools (like Apache Mesos and Docker Swarm), K8s is by far the most popular.

Of course, “management” and “orchestration” are vague terms. So, what exactly can Kubernetes do? Let’s take a look:

Rollouts and rollbacks: K8s allows you to automate the creation and deployment of new containers or removal of existing containers in a container cluster based on predefined rules around resource utilization.
Storage mounting: With Kubernetes, you can automatically mount storage resources for your containers.
Resource allocation: Balancing CPU and RAM consumption at scale is a challenging task. K8s enables you to define CPU and RAM requirements and then it automatically handles optimal deployment of your containers within the constraints of your resources (nodes).
Self-healing: With K8s, you can define health checks and if your containers do not meet the requirements, they will be automatically restored or replaced.
Configuration management: K8s helps securely manage container configurations including sensitive data such as tokens and SSH keys.
Load balancing: Kubernetes can automatically perform load balancing across multiple containers to enable efficient performance and resource utilSecuring containers.

You may think that because containers are isolated, they are “secure”. Unfortunately, it’s not that simple. While it’s true containers are isolated from one another in userspace, misconfigurations, vulnerabilities, and malicious actors all pose threats. Simply put: securing your containers is a must.

There are many specific container security considerations you must account for when containerizing applications. For example, continuous monitoring of container registries for new vulnerabilities and leveraging container firewalls are important aspects of comprehensive container security. Additionally, securing the host operating system your container engine runs on is a must.

Of course, securing containerized applications means you must take application security (appsec) seriously as well. That means taking a holistic view of your environment, creating security profiles, identifying threats, and leveraging tools like Interactive Application Security Testing (IAST) solutions and Web Application Firewalls (WAFs) where appropriate.

Containerization Security with Check Point

Check Point products like CloudGuard are purpose-built with DevOps pipelines and container security in mind. As industry leaders in the containerization security space, we know what it takes to get container security right. For a deep dive into the world of containerization security, download our free Guide to Container and Kubernetes Security today. In that free guide you’ll learn about:

Modern microservices, K8s, and container security approaches.
Best practices for container security.
How to automate workload protection and threat prevention within cloud native environments.

Additionally, if you’re responsible for securing multi-cloud environments, you’re welcome to read our free Achieving Cloud With Confidence in the Age of Advanced Threats whitepaper. In that paper, you’ll gain robust insights into threat prevention and infrastructure visibility in multi-cloud environments.