Mesos vs Kubernetes - Which One to Choose?

Posted in

Mesos vs Kubernetes - Which One to Choose?

Pankaj Bhadwal
Last updated on June 10, 2022

    If you are a developer or system administrator, you might have definitely come across the term ‘container.’ A container is an executable unit of software that combines application code with its dependencies and libraries so that it can run on any computing environment. Containers are the best solution to run your software effectively when you move it from one computing environment to another.

    On the other hand, a single container is insufficient to execute your application and fulfill microservice requirements. As a result, you'll need several container instances, but maintaining, monitoring, and scaling them is time-consuming and can be disastrous if not done properly. This is where container orchestration tools come in handy.

    Container orchestration aims to automate the processes of deploying, managing, scaling, and networking containers. When enterprises need to handle the deployment and management of hundreds of containers, container orchestration becomes a viable option. The two popular container orchestration tools used extensively are Apache Mesos and Kubernetes.

    This article will help you understand the major differences between Apache Mesos and Kubernetes. Also, you will learn how to figure out which tool among Mesos and Kubernetes suits your application needs the best.

    So, let us begin!

    What is Apache Mesos?

    Apache Mesos is an open-source cluster manager. It manages containerized and non-containerized workloads in a distributed environment through dynamic resource isolation and sharing. The primary goal of Mesos is to bring the existing resources of machines or nodes into a single cluster, and a variety of workloads can use those resources.

    Mesos utilizes cgroups for CPU, I/O, file system, and memory isolation. Moreover, Mesos is analogous to Google’s Borg Scheduler. This scheduler manages and distributes Google services.

    • Apache Aurora: Apache Aurora is a Mesos framework for long-running services and cron jobs. Twitter started the development of this framework in 2010 and made it open-source in late 2013.
    • Chronos: Chronos is a cron-like system. This system is elastic and can express dependencies between jobs.
    • Marathon: Marathon is a container orchestration system that can scale up to thousands of servers. It is a REST-based system written in Scala. It allows canary-style deployments and development topologies.


    The development of Mesos started as a research project at the UC Berkeley RAD Lab. Later, three Ph.D. students, namely Benjamin Hindman, Andy Konwinski, and Matei Zaharia, and one professor, Ion Stoica, started working on that research project.

    Originally, they named the project Nexus, but they renamed it Mesos due to conflicts with other universities. While its name was Nexus, Andy Konwinski at HotCloud '09 in 2009, presented it, along with the first paper published about the project. Later, Zaharia, at the Usenix Symposium in 2011, presented the project with the paper "Mesos: A Platform for Fine-Grained Resource Sharing in the Data Center".

    In 2006, the Apache Software Foundation announced version 1 of Apache Mesos.


    The following are the salient features of Apache Mesos:

    • Linear scalability: Apache Mesos is capable of scaling up to 10,000s nodes.
    • High-Availability: Apache Mesos provides high-tolerant replicates of Master and agents using Zookeeper.
    • Containers: Mesos provides native support for launching containers with Docker and AppC images.
    • Pluggable Isolation: Mesos provides first-class isolation support for CPU, memory, disk, GPU, and ports.
    • Two-Level Scheduling: The pluggable scheduling policies of Mesos provide support for running cloud-native and legacy applications in the same cluster.
    • Web UI: Mesos has a built-in web UI for viewing cluster states and navigating cluster sandboxes.


    The following are the advantages of Apache Mesos:

    • Apache Mesos can handle containerized and non-containerized workloads.
    • It provides Java, Python, and C++ APIs for building new parallel applications.
    • Mesos makes it possible to integrate existing workloads with the application currently under development.


    Here are the disadvantages of Apache Mesos:

    • It is pretty tricky to configure Mesos for the proper memory and CPU usage.
    • It has a steep learning curve.
    • Documentation is poor in some cases, and hence, you may find it difficult to get started in certain areas.
    • If there is a bunch of tasks in queue, the Mesos slave becomes non-responsive in some cases.
    • Mesos has tight integration with Zookeeper. Sometimes, Zookeeper may become the reason for memory issues, which lead to instability.

    When to Choose Apache Mesos?

    Apache Mesos is best suited if you wish to work with existing containerized and non-containerized workloads. Meaning that if you want to integrate existing workloads with the currently deploying containerized application, Mesos is an excellent choice.

    What is Kubernetes?

    Kubernetes, also referred to as K8s, is an open-source system that facilitates the automation of deployment, scaling, and management of containerized applications. It is a set of building blocks or primitives that provides mechanisms for deploying, scaling, and managing applications based on CPU, memory, and other custom metrics.

    Furthermore, Kubernetes is a loosely-coupled and extensible system to handle different workloads. The Kubernetes API makes it possible for internal components, extensions, and containers to run on Kubernetes.


    Joe Beda, Brendan Burns, and Craig McLuckie are the founders of Kubernetes. Later, Brian Grant and Tim Hockin who are engineers at Google, joined the team to develop Kubernetes. The design and development of Kubernetes were highly influenced by Google’s Borg system.

    Initially, Google named Kubernetes Project 7, which refers to the seven spokes on the wheels of the Kubernetes logo. In July 2015, Google and Linux Foundation partnered to form the Cloud Native Computing Foundation (CNCF). This foundation offers Kubernetes as a seed technology.

    In 2016, the Cloud Native Computing Foundation (CNCF) released the Helm package for Kubernetes. Until Kubernetes 1.18, all the versions follow the N-2 support policy. All the later versions follow the N-3 support policy.


    The following are the salient features of Kubernetes:

    • Automated Rollouts and Rollbacks: Kubernetes can roll out any changes made to your application or its configuration. It also monitors the health of your application so that it does not kill all your instances at the same time. In addition, Kubernetes can roll back the change for you.
    • Storage Orchestration: Kubernetes automatically mounts the desired storage system from local storage, public cloud providers, such as AWS and Google Cloud , or network storage systems, such as Cinder, Flocker, or NFS.
    • Automatic Pin Backing: Kubernetes automatically positions containers depending on their resource requirements and other constraints.
    • Horizontal Scaling: You can scale your application up and down with a UI, simple command, or automatically using CPU storage.
    • Batch Execution: Kubernetes is capable of managing batch services and workloads.
    • Service Discovery and Load Balancing: Kubernetes automatically assigns a unique IP address to each container and a DNS name to the set of containers called Pods. Doing this can balance traffic within the cluster.
    • Self-Healing: Kubernetes can automatically restart the containers that failed during execution. Also, it kills the containers that do not respond to user-defined health checks. However, if a node dies, Kubernetes reschedules the execution of the containers present on that node to other available nodes.

    Advantages of Using Kubernetes

    The following are the major upsides of Kubernetes:

    • Kubernetes provides the ability to be more productive while developing applications. It enables you to efficiently develop Platform-as-a-service (PaaS) applications.
    • You can find a variety of tools developed for and around Kubernetes. Some major tools include Helm and Kubectl.
    • Kubernetes has a strong community, where people help each other in case of issues while working with Kubernetes.
    • It can easily adapt to the usage and maintenance requirements of distributed applications.
    • You can run any type of application on the Kubernetes engine, including replicated, stateful, co-located applications and microservices.
    • It provides native security features to protect your application from vulnerabilities and threats.
    • Kubernetes is compatible with popular cloud service providers, including AWS and GCP.


    Here are the significant downsides of Kubernetes:

    • It may be pretty difficult to migrate existing applications to Kubernetes.
    • Kubernetes is more expensive than its alternatives.
    • It is not ideal for building small applications since the cost and resources required to build them using Kubernetes are high.

    When to Choose Kubernetes?

    Kubernetes is the best choice when you don’t have any existing workload and plan to use only containerized workloads. If organizations wish to move from small-scale application deployment to cloud-native deployment, they can choose Kubernetes. Also, it is a great choice for beginners since it has a simple architecture.

    Apache Mesos vs Kubernetes - Head-to-Head Comparison

    The following table highlights the major differences between Apache Mesos and Kubernetes:

    Parameters Apache Mesos Kubernetes
    Definition Apache Mesos is an open-source cluster manager that handles containerized and non-containerized workloads across a distributed environment. Kubernetes is an open-source system that automates the deployment, management, and scaling of containerized applications.
    Supported Workloads Mesos is capable of handling a variety of workloads that can be containerized or non-containerized. It is capable of handling only containerized applications. Generally, we use Kubernetes with Docker containers . It also supports other container runtimes, including Rkt and CRI-O.
    Scaling Scaling in Mesos is achieved by scheduling a framework that can modify the scale of an application through its UI or application definition. An entity called Horizontal Pods Autoscaler is responsible for managing scalability.
    Failover Management In Mesos, Zookeeper Quorum manages the master node failover. On the other hand, the master node manages application failover. This master node maintains the state of an application by using the data the Mesos agent, running on the worker nodes, publishes. Kubernetes manages an application failover with readiness and liveness checks. Moreover, the master node is self-managed in Kubernetes.
    High Availability Marathon, a container orchestration system in Mesos, distributes application instances across various Mesos agents, which ensures high availability. Similarly, Kubernetes replicates Pods across multiple nodes, which ensures availability.
    Load Balancing Mesos-DNS is responsible for providing service discovery, and load balancing. We generally use Service to expose pods in Kubernetes, which also provides service discovery. In addition, Service acts as a dispatcher to the pods, and hence, provides load balancing.
    Networking In Mesos, container runtime offers two types of networking support, namely IP-per-container, and network-port-mapping. In Kubernetes, networking assigns a unique IP to each pod, which eliminates the need to map the container port to the host port.
    Storage There are persistent local volumes in Mesos for stateful applications. We can only create persistent volumes from the reserved resources. There are multiple types of persistent volumes in Kubernetes for stateful containers, which include storage like iSCSI and NFS.

    Apache Mesos vs Kubernetes - Which is Better?

    Both Apache Mesos and Kubernetes are powerful container orchestration and management solutions. Also, both of these tools are capable of managing Docker containers. They provide access to container orchestration for the portability and scalability of applications.

    Kubernetes cluster can scale up to 5000 nodes, while Marathon in Mesos can scale up to 10,000 agents. In terms of scaling, Apache Mesos outperforms Kubernetes.

    Another major factor to consider while choosing between Apache Mesos and Kubernetes is the type of workload. If you are starting afresh and plan to use only containerized workloads, Kubernetes is an ideal choice. On the flip side, if you have an existing workload that is a collection of containers and non-container, choosing Mesos would be a great move.

    Therefore, the ultimate choice between Mesos and Kubernetes depends upon the type of workloads and the company’s present and future requirements.


    Apache Mesos and Kubernetes are both equivalent in terms of features, and each orchestration system has its own strengths. Both make it easier to deploy and manage applications inside containers.

    Kubernetes has a simple-to-use architecture, which makes it user-friendly for beginners, while Mesos has a steep learning curve. Kubernetes is best suited for start-ups and organizations who wish to shift from small-scale application deployments to cloud-native deployments.

    On the other hand, if you have existing workloads and wish to integrate with your containerized application that is currently under development, Mesos provides you with a framework that can handle all workloads in a single cluster.

    We hope that this post has given you enough information to make an informed decision between Apache Mesos vs Kubernetes.

    Frequently Asked Questions

    1. Is Kubernetes better than Apache Mesos?

    Kubernetes and Apache Mesos are best in their own ways. Kubernetes is the best choice if you are starting afresh and using only containerized workloads. On the other hand, Apache Mesos is ideal to choose when you have existing workloads, which combine containers and non-containers.

    2. What is DC/OS in Mesos?

    DC/OS in Mesos stands for Datacenter Operating System. It is an open-source distributed operating system based on Apache Mesos distributed systems kernel. It is available as an open-source as well as a commercial offering. Moreover, DC/OS can manage multiple machines on-premises and in the cloud from a single interface.

    3. What companies use Mesos?

    Some popular companies that use Apache Mesos include Airbnb, Twitter, Netflix, eBay, Hubspot, Indeed, Uber, Paralect, Kasa, Zalando, and Apple (Siri).

    4. What companies use Kubernetes?

    Top companies that use Kubernetes include Google, Spotify, Pinterest, Tinder, The New York Times, Capital One, Udemy, Slack, StackShare, Shopify, and Nubank.

    People are also reading:

    Leave a Comment on this Post