Containers are lightweight, executable application components that combine application source code with all the operating system (OS) libraries and dependencies required to run the code in any environment. 

The ability to create containers has existed for decades, but it became widely available in 2008 when Linux® included container functions within its kernel. It became even more essential after the arrival of the Docker open source containerization platform in 2013. (Docker is so popular that "Docker containers" and "containers" are often used interchangeably.) Today, containers are compatible with many other operating systems besides Linux, including Windows.

Because they are smaller, more resource-efficient and more portable than virtual machines (VMs), containers—and more specifically, containerized microservices or serverless functions—have become the de facto compute units of modern cloud-native applications.

In small numbers, containers are easy enough to deploy and manage manually. However, containerized applications and the need to manage them at scale have become ubiquitous in most large-scale organizations.

For instance, a continuous integration/continuous delivery (CI/CD) or DevOps pipeline is impossible without container orchestration, which automates the operational tasks concerning deploying and running containerized applications and services.

In an IBM study, 70% of surveyed developers are using container orchestration solutions, and 70% of those who do use a solution report using a fully managed (cloud-managed) container orchestration service at their organization.  

Container orchestration architecture consists of running container clusters across multiple machines and environments. Each cluster typically consists of a group of nodes (also called server instances). Worker nodes run containers using container runtimes (such as Docker). A group of control plane nodes act as the orchestrator of the cluster. Users can manage and monitor containerized workloads with tools featuring application programming interfaces (APIs) and graphical user interfaces (GUIs).

While there are differences in methodologies and capabilities across platforms and tools, container orchestration is essentially a three-step process (or cycle, when part of an iterative agile or DevOps pipeline):

1. Provisioning
2. Deployment
3. Lifecycle management

1. Provisioning

Most container orchestration tools support a declarative configuration model. A developer writes a configuration file (in YAML or JSON, depending on the tool) that defines a wanted state. The orchestration tool that runs the file uses its own intelligence to achieve that state. The configuration file typically does:

• Define which container images make up the application and where they are located (in what container registry).

• Provision the containers with storage and other resources.

• Define and secure the network connections between containers.

• Specify versioning (for phased or canary rollouts).

2. Deployment

The orchestration tool schedules the deployment of the containers (and replicas of the containers for resiliency) to a host. It chooses the best host based on available the central processing unit (CPU) capacity, memory or other requirements or constraints specified in the configuration file. 

3. Lifecycle management

Once the containers are deployed, the orchestration tool manages the lifecycle of the containerized application based on the container definition file (often a Dockerfile).

Lifecycle management tasks include:

• Manage scalability (up and down), load balancing and resource allocation among the containers.

• Help ensure availability and performance by relocating the containers to another host if there is an outage or a shortage of system resources.

• Collect and store log data and other telemetry that monitor the health and performance of the application.

Check out this video for a closer look at how container orchestration works:

The main benefits of container orchestration include:

• Automation

• Resilience

• Enhanced resource usage and performance

• Cost-efficiency

• Speed and agility

• Improved security

• Increased productivity

Automation

The chief benefit of container orchestration is automation, which greatly reduces the manual effort and complexity of managing a large-scale containerized application estate.

Resilience

Container orchestration solutions enhance resilience by restarting or scaling containers if one fails. This capability helps ensure availability and increased application uptime.

Enhanced resource usage and performance

Automated host selection and resource allocation can maximize the efficient use of computing resources. For example, a container orchestration solution can adjust the CPU memory and storage based on an individual container, which prevents overprovisioning and improves overall performance.

Cost efficiency

Container orchestration removes the need for manual intervention, lowering operational costs. Also, containers require fewer resources than VMs, which can reduce IT infrastructure needs and overhead costs.

Speed and agility

Container orchestration tools help speed app development and deployment, providing critical support for modern cloud-native processes.

Improved security

Containers improve security by isolating applications from the host system and each other, reducing attack surfaces. Many platforms contain automated scanning to detect vulnerabilities and secure image registries, enhancing overall protection.

Increased productivity

By automating operations, container orchestration supports an agile or DevOps approach. This allows teams to develop and deploy in rapid, iterative cycles and release new features and capabilities faster.

Developed by Google and released in 2014, Kubernetes became one of the fastest-growing projects in open source software's history. Kubernetes is currently maintained by the Cloud Native Computing Foundation (CNCF). Since Kubernetes joined the CNCF in 2016, the number of contributors has grown from 731 to 8,012.¹

With other container ecosystem tools, Kubernetes enables a company to deliver a highly productive platform as a service (PaaS). This cloud computing model addresses many infrastructure- and operations-related tasks and issues around cloud-native application development so that development teams can focus exclusively on coding and innovation.

Kubernetes' advantages over other orchestration solutions are largely a result of its more comprehensive and sophisticated functions in several areas:

• Container deployment

• Rollouts

• Service discovery

• Storage provisioning

• Load balancing and scalability

• Self-healing for high availability

• Support and portability across multiple cloud providers

• Open source ecosystem

Container deployment

Kubernetes deploys a specified number of containers to a specified host and keeps them running in a wanted state.

Rollouts

A rollout is a change to a deployment. Kubernetes lets developers initiate, pause, resume or roll back rollouts.

Service discovery

Kubernetes can automatically expose a container to the internet or to other containers by using a Domain Name System (DNS) name or IP address to discover services.

Storage provisioning

Developers can set Kubernetes to mount persistent local or cloud storage for their containers as needed.

Load balancing and scalability

When traffic to a container spikes, Kubernetes can employ load balancing and autoscaling to distribute traffic across the network and help ensure stability and performance. This capability also saves developers the work of setting up a load balancer.

Self-healing for high availability

When a container fails, Kubernetes can restart or replace it automatically. It can also take down containers that don't meet an organization’s health check requirements.

Support and portability across multiple cloud providers

Kubernetes enjoys broad support across all leading cloud providers. This capability is essential for organizations deploying applications to a hybrid cloud (the combination of public cloud, private cloud and on-premises infrastructure) or multicloud (the use of cloud services from more than one cloud vendor).

Open source ecosystem

Kubernetes also has an ever-expanding stable of usability and networking tools to enhance its capabilities via the Kubernetes API. These include Knative, which enables containers to run as serverless workloads, and Istio, an open source service mesh.