Why Containers are more popular than Virtual Machine?
Tags: aws, cloud, virtualmachine, containers
Published: 2023-05-31 18:53:17

## **Virtualization**

_Virtualization_ is quite an old concept. It began in the 1960s to logically divide the system resources provided by mainframe computers into individual applications. Being an old technology, it is still a relevant part of cloud computing.

_Virtualization_ uses software to create an abstract layer over hardware allowing hardware elements such as storage, computing, and memory to get distributed among multiple virtual machines (VM). Each VM has its separate operating system (OS), acting like an individual machine even though it shares the underlying hardware with multiple other VMs.

The abstraction layer is a piece of software known as a _Hypervisor_. It is a crucial component in the virtualization process which serves as an interface between the VM and the underlying physical hardware. It ensures that VMs do not interrupt each other. It stands on top of a host or a physical server. The main task of a _hypervisor _is to pool resources from the physical server and allocate them to different virtual environments.

There are two types of hypervisors:
**Type 1 or "bare metal" hypervisors**: A Type 1 hypervisor runs directly on the physical hardware of the underlying machine, interacting with its CPU, memory, and physical storage.
**Type 2 hypervisors**: A Type 2 hypervisor does not run directly on the underlying hardware. Instead, it runs as an application in an OS.

## **Virtual Machine**

![Virtual Machine](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/el7v0g42v5j433smcfho.png)

A _virtual machine _(VM) is a virtual environment that behaves like a virtual computer system, **complete with its CPU, memory, network interface, and storage.**

AWS refers to them as _EC2 instances_; _EC2 instances_ are _virtual machines_ that emulate physical hardware components. An _EC2 instance_ can do anything that a physical computer can do. You choose your compute options based on: **CPU, memory, and storage.** You choose the OS and maintain all security and patching of the instance. You can scale up or down the resources as needed.

## **Containers**

![Containers](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/niw2sahnlj44uwiortgb.png)

_Containers_ are software components that package application code, along with required executables such as **libraries, dependencies, binary codes, and configuration files**, using operating system virtualization in a standardized manner. _Containers_ can run on various platforms, including desktops, traditional IT environments, and cloud infrastructures.

_Containers_ are **lightweight, portable, and swift** because they do not include operating system images, like virtual machines. As a result, they have less overhead and can leverage the features and resources of the host operating system, making them highly portable and easy to deploy.

AWS provides two services for container management:
**1. Amazon Elastic Container Service (Amazon ECS)
2. Amazon Elastic Kubernetes Service (Amazon EKS)**

## **Amazon Elastic Container Service (Amazon ECS)**
_Elastic Container Service (ECS)_ is a fully managed container orchestration service provided by AWS. _ECS _simplifies the d**eployment, management, and scaling of Docker containers on AWS, and enables customers to build highly scalable and resilient microservices-based applications.**

_ECS _has two main components: the **ECS service** and the **ECS agent**. The **ECS service** is responsible for managing the container instances, tasks, and services, and provides APIs and a console for customers to interact with. The **ECS agent** is a lightweight daemon that runs on each EC2 instance or Fargate instance and communicates with the ECS service to register the instance and start, stop, and monitor containers.

There are two ways to set up an Amazon ECS cluster:

1. **EC2**: With EC2 instances, customers can choose their own instances and scale the cluster as needed.
2. **Fargate**: With Fargate, AWS manages the instances for customers, and they only pay for the resources their containers use.

_ECS _supports both **Linux and Windows containers**, and provides features such as load balancing, auto scaling, service discovery, and integration with other AWS services.

_ECS _integrates with other AWS services such as **Amazon CloudWatch for monitoring, AWS Identity and Access Management (IAM) for access control, and Amazon Elastic Container Registry (ECR) for storing and managing Docker images.** ECS also supports integration with third-party tools such as Jenkins.

## **Amazon Elastic Kubernetes Service (Amazon EKS)**
_Elastic Kubernetes Service (EKS)_ is a fully managed Kubernetes service provided by AWS. _EKS_ simplifies the **deployment, management, and scaling of containerized applications using Kubernetes on AWS, and enables customers to build highly scalable and resilient microservices-based applications.**

Kubernetes is an open-source container orchestration system that automates containerized applications' deployment, scaling, and management. EKS allows customers to run Kubernetes clusters on a managed cluster of EC2 instances or Fargate instances same as ECS.

_EKS_ has two main components: the **EKS control plane** and the **worker nodes**. The **EKS control plane** is responsible for managing the Kubernetes control plane, including the API server, etcd, and other components. The control plane is highly available, automatically scales, and is managed by AWS. The **worker nodes** are the EC2 or Fargate instances running the containerized applications. _EKS_ automatically provisions, scales, and manages these nodes, and customers can use Amazon EC2 Auto Scaling groups to scale the nodes based on demand.

_EKS _integrates with other AWS services such as **Amazon CloudWatch for monitoring, AWS Identity and Access Management (IAM) for access control, and Amazon Elastic Container Registry (ECR) for storing and managing container images.** EKS also supports integration with third-party tools such as Jenkins.

## **Difference between containers and virtual machines (VMs)**

![Containers and Virtual Machine](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/qlclep9vov0wwam8qgwu.png)

Containers and virtual machines are two distinct approaches to virtualizing computing resources. Virtual machines virtualize all components down to the hardware level, generating multiple instances of operating systems on a single physical server. In contrast, containers virtualize solely the software layers above the operating system, forming lightweight packages that incorporate all the dependencies required for a software application. Containers can operate more workloads on a single operating system instance than virtual machines, making them faster, more flexible, and more portable.

## **Advantages**

1. Containerized applications are **portable** and can be used in other cloud environments or returned to an on-premises datacenter, which helps businesses avoid vendor lock-in.
2. A container is more **lightweight**. They start up faster, nearly instantly. This difference in starting time is important when designing applications that are required to scale quickly during I/O bursts.
3. Containers offer the **flexibility and portability** that is ideal for the **multi-cloud** world. When developers design new applications, they may not be aware of all of the locations where they will need to be deployed. Today, a corporation may run a program on its private cloud, but tomorrow it may need to deploy it on a public cloud. Containerizing applications gives teams the flexibility they need to deal with today's diverse software environments.
 

## **Use cases of Containers**

- **Increased developer's productivity**

![](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/8v0h8mkh4t7ddgvcgu6v.png)

While testing an early version of an application, a developer can run it from their PC without hosting it on the primary operating system or creating a testing environment. Furthermore, containers eliminate problems with environment settings, handle scalability challenges, and simplify operations. Because containers solve numerous challenges, developers can concentrate on development rather than dealing with operations.

In these Configuration files, the code of the application, dependencies, and the runtime engine are packaged all together in a robust manner known as a container that can run on any environment independently.

- **Great for CI/CD**

Containers also make it easier to develop a CI/CD pipeline, provide more frequent updates, and create repeatable deployment processes. Because containers are lightweight and agile, each container contains much less code than updating an entire VM, and containers run in the same environment at every stage of development, there is little risk that a containerized application will work perfectly in development and then fail in production.

- **Containers can run on IoT devices**

Using containers suit installing and updating applications on IoT devices. That is because containers encompass all the required software for the applications to function, making them easily transportable and lightweight, which is particularly beneficial for devices having restricted resources.

- **Great for Micro-service architecture**

![](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/iwophhii50qoby5ep6zy.png)


Containers support microservice architectures, allowing for more precise deployment and scaling of application components. They are preferred over scaling up an entire monolithic application simply because a particular component faces difficulty.

- **Hybrid and multi-cloud compatible**

![](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/3pz3r02z3cl49nr0c0nz.png)


Containers provide flexibility in app deployment, allowing for the creation of a unified environment that can run on-premises and across multiple cloud platforms. This makes it possible to optimize costs and enhance operational efficiency by leveraging existing infrastructure and utilizing the benefits of different cloud providers with the workload.

## **Conclusion**
Containers have surpassed virtual machines in popularity due to their lightweight design, shorter deployment times, and efficient resource utilization, particularly for current, cloud-native apps. However, both technologies will coexist and evolve, and organizations should select the best tool for the job based on their specific needs and goals.