Modern Enterprise Apps Operations With DC/OS

 
Modern Enterprise Apps Operations With DC/OS
MODERN ENTERPRISE
APPS OPERATIONS
WITH DC/OS
Lessons from Running Containers,
Microservices, and Stateful Big Data
Services in Production

WHITE PAPER
Modern Enterprise Apps Operations With DC/OS
Modern Enterprise Apps
                                                                                                                                                                           Operations with DC/OS

                      Table of Contents
                      Executive Summary.................................................................................................................................................. 3
                      A New Battlefront for Enterprises ............................................................................................................................ 3
                      The Modern Enterprise App ..................................................................................................................................... 5
                              Architectural Components of Modern Enterprise Apps.................................................................................. 5
                              Microservices ................................................................................................................................................... 6
                              Containerization .............................................................................................................................................. 6
                              Enterprise Big Data .......................................................................................................................................... 7
                              Open Source .................................................................................................................................................... 7
                      Modern App Engineering and Operations ............................................................................................................... 8
                              Engineering Challenges of the Modern Enterprise App .................................................................................. 8
                              Resource Management Challenges ................................................................................................................. 9
                              Hyperscale Computing vs. IaaS Operating Models......................................................................................... 9
                      The Datacenter Operating System Model.............................................................................................................. 10
                              Developer and Operator Experience ............................................................................................................. 10
                              Apache Mesos the Enabling Technology ...................................................................................................... 11
                      Platform Considerations for Modern Enterprise Apps .......................................................................................... 12
                      DC/OS Model Business Outcomes ......................................................................................................................... 13
                              Hyperscale Operations .................................................................................................................................. 13
                              Developer Agility ............................................................................................................................................ 14
                              Data Agility ..................................................................................................................................................... 14
                      Transitioning Towards the DC/OS Operating Model ............................................................................................. 15
                      Conclusions ............................................................................................................................................................ 16
                      About the Authors .................................................................................................................................................. 16

Copyright © Mesosphere, Inc. 2016                                                                                                                                           WHITE PAPER | 2
Modern Enterprise Apps Operations With DC/OS
Modern Enterprise Apps
                                                                                                                      Operations with DC/OS

                      Executive Summary
                      As Marc Andreessen foresaw almost five years ago: Software is eating the world. Businesses of all types need
                      to develop and deploy new software services, quickly, to stay competitive. This turns out to be quite
                      challenging because enterprises must: (1) Quickly adopt entirely new processes for building and deploying
                      software, including such modern concepts as microservices, containers, and continuous integration and
                      deployment; (2) Ingest and store vast amounts of data, in real time, such as from machine sensors and
                      customer and business activities; and (3) Derive actionable insight from data, again in real time, in order to
                      save money, respond to market conditions more quickly, and deliver better products and services.

                      IT organizations must meet these challenges while addressing the traditional concerns of efficiency, security,
                      service quality, and operational flexibility. Early web companies like Google and Facebook were the first to
                      encounter these challenges and found the answer in hyperscale computing — modern applications composed
                      of distributed microservices with big-data built-in — often running on commodity hardware. For mainstream
                      enterprises, building and operating modern apps can be a significant challenge. The Datacenter Operating
                      System (DC/OS) applies best practices established by early web companies, and is powered by the
                      production-proven Apache Mesos distributed systems kernel. With DC/OS, modern apps are now practical for
                      mainstream enterprises.

                      A New Battlefront for Enterprises
                               About a decade ago, web companies like Google, Facebook and Netflix addressed the challenge of
                               serving millions of users in real time and processing unprecedented volumes of data. This started a
                               quiet revolution in the datacenter, and launched the start of the mobile-cloud era — dramatically
                      raising user expectations, creating new businesses, and placing competitive pressures on industries like retail,
                      manufacturing, healthcare, and financials, among others.

                      Today, mainstream enterprises are looking for ways to better engage customers, improve operational
                      decision-making, and capture new value streams. Doing this requires the enterprise to develop two related
                      capabilities. The first is developer agility — rolling out new services or product enhancements quickly, and
                      reducing time to value of new services. The second is data agility — gaining actionable insights from the large
                      volume of data enterprises are collecting.

                      The idea that enterprises need to get faster and smarter is not controversial. The real battlefront, and the
                      question business leaders need to answer, is how to find the right technologies, operating models and talent
                      that can collectively enable developer and data agility.

Copyright © Mesosphere, Inc. 2016                                                                                      WHITE PAPER | 3
Modern Enterprise Apps Operations With DC/OS
Modern Enterprise Apps
                                                                                                                         Operations with DC/OS

                                 Developer agility isn’t about getting developers to code faster. It’s about getting code to production
                                 faster. Rolling out new services quickly means enterprises need to change how they build and
                                 operate software. No longer can enterprises afford to build legacy-style, monolithic applications
                      that run in virtual machines (VMs), Instead, the modern enterprise needs to adopt new ways of doing things
                      (e.g., microservices in containers) and select a technology stack that eliminates the latency from concept to
                      development to production, while managing risk.

                      In today’s mobile-cloud era, software is evolving towards distributed systems and microservices (sometimes
                      called “cloud native”). This approach provides service scalability and maintainability, and increases the speed
                      that software can be deployed, especially when used in conjunction with continuous integration and
                      continuous delivery models. Many think of cloud native apps as inherently stateless. However, modern
                      enterprise apps cannot be entirely stateless since they need to rely on data — either to support a business
                      function, or to engage customers in a meaningful way. And it’s not just about data for stateful apps. The way
                      enterprises are using big data is shifting.

                              There have been two major waves of big data in the enterprise. The first enterprise big data efforts
                              essentially built large data warehouses (and tools) for use by analysts or data scientists. In the
                              current second wave, successful enterprises are building business applications powered by big data,
                      capturing the value of actionable insights in real time.

                      First wave big data efforts had mixed results. Gartner’s 2015 Hadoop Adoption Survey1 cited 49 percent of
                      respondents were “struggling to figure out how to get value from Hadoop.” There are three main reasons.
                      First, the technology stack these enterprises have sought to build is just too complex and inflexible. Second,
                      most mainstream enterprises do not have the engineering expertise of companies like Google. Third, big data
                      initiatives were often ill-defined2 projects akin to “give us your data, and we will find new patterns and insights
                      to drive your business.” The result has been heavy investment yielding some insights, with little impact to the
                      business.

                      Successful enterprises leading the second wave of big data are shifting from building systems of record (e.g.,
                      “what were last quarter's sales of a product in a particular segment”) to systems of real-time insight and
                      prediction (e.g., “what is an individual customer likely to buy, and what types of engagement can best
                      influence their behavior?”). These businesses are deriving true value out of their big data efforts and for those
                      still stuck in the first wave, competitive pressures are mounting.

                                The battlefront for business leaders today is finding the right technology, operating model, and
                                talent to deliver new services quickly and leverage insights from stateful big data services. The
                                technology should also provide flexibility and not be locked into a particular vendor, or cloud.
                      Because the answer lies in distributed application architectures, the virtual machine is the wrong abstraction
                      for addressing these challenges — a new approach to building apps is needed. For the small number of
                      successful companies that have been successful, a clear pattern has emerged: the modern enterprise
                      application architecture.

                      1
                       Gartner, Inc. 2015 Hadoop Adoption Study
                      2
                       McKinsey & Company. Getting big impact from big data. McKinsey Quarterly January 2015
                     http://www.mckinsey.com/business-functions/business-technology/our-insights/getting-big-impact-from-
                     big-data
Copyright © Mesosphere, Inc. 2016                                                                              WHITE PAPER | 4
Modern Enterprise Apps Operations With DC/OS
Modern Enterprise Apps
                                                                                                                         Operations with DC/OS

                      The Modern Enterprise App
                      The revolution started at companies like Google and Facebook, with what we now call hyperscale computing.
                      Faced with the challenge of serving billions of users in real time and rolling out new ideas quickly, these early
                      web companies realized that the traditional monolithic application stacks and the underlying virtual machine
                      architecture did not have the scalability and speed required to instantly launch thousands of workloads. With
                      large budgets for infrastructure and armies of highly skilled engineers, these companies developed
                      proprietary hyperscale stacks to address challenges specific to their business.

                      Architectural Components of Modern Enterprise Apps
                      The patterns they used form the basis of the modern enterprise app. In a modern enterprise app, application
                      functions and logic are implemented as microservices, and packaged and deployed in containers, tightly
                      integrated with big data. Some or all of these components may be open source technology. Enterprises are
                      already adopting many of these patterns, and while containerization is increasingly common, containerization
                      by itself is not sufficient for most enterprises.

                              Microservices — Enable teams to work self-sufficiently, and deliver and iterate quickly
                              Containers — Simply packaging of code (often stateless)
                              Big Data — Process information and retain the states of modern apps
                              Open Source — Leverage the work of others in building the application

Copyright © Mesosphere, Inc. 2016                                                                                        WHITE PAPER | 5
Modern Enterprise Apps Operations With DC/OS
Modern Enterprise Apps
                                                                                                                      Operations with DC/OS

                      Microservices
                      The basic principle of microservices architecture is to decompose the application into a set of collaborating
                      services, rolled out in the smallest deployable units. Each microservice implements a set of narrowly defined
                      functions. Most commonly, these microservices interface with each other using the REST protocol. The
                      benefits of microservices include the ability to have many teams working on different components in parallel,
                      building and deploying independently, scaling only portions of an application that need the additional
                      capacity, and being able to update/upgrade portions of the application without impacting users, as long as
                      API contracts between microservices are maintained.

                      The real power of microservices architecture is in enabling small cross-functional teams to build and deploy
                      functions independently using continuous integration and continuous deployment pipelines. These
                      techniques enable enterprises to create and sustain autonomous and innovative teams that can build highly-
                      scalable applications easily and new functionality quickly.

                      Containerization
                      When applications are engineered as independently-deployed microservices, those microservices need a
                      nimble infrastructure on which to run. For modern enterprise apps, containerization is the simplest and best
                      way to run microservices, better than virtual machines because they are faster to spin up (and kill) and allow
                      greater workload density. Containerization consists of two main components: the container image and the
                      container runtime.

Copyright © Mesosphere, Inc. 2016                                                                                      WHITE PAPER | 6
Modern Enterprise Apps Operations With DC/OS
Modern Enterprise Apps
                                                                                                                        Operations with DC/OS

                      Container images are an elegant way for developers to package their apps, provide their code access to all the
                      libraries they need, and give their code the illusion of the entire machine’s filesystem, without actually
                      including the operating system, unlike a virtual machine. Docker has become the most commonly used
                      container image.

                      The container runtime is responsible for executing what’s defined in a container image and creating a running
                      process from the image. Several container runtimes exist, and all support the Docker container image format.
                      Below is an overview of container runtimes and the container images they support.

                                    Container Runtime                   Supported Container Image

                                    DCOS w/Mesos                        AppC, Docker, Mesos, OCI*

                                    Docker                              Docker

                                    Rocket                               AppC, Docker, OCI*

                                    * Based on public Roadmaps

                      Enterprise Big Data
                      Big data is a reality for modern enterprise apps because any valuable enterprise service will either use or
                      produce data with appreciable velocity, variability and volume. Modern enterprise apps aim not to support
                      data scientists’ investigations, but to capture the value of data insights in real time through services. Examples
                      include:

                                    Personalization — delivering a unique and engaging real-time experience for customers
                                    Anomaly detection — identifying potential cases of financial fraud, security breaches, or serious
                                     medical conditions, all in real-time
                                    Internet of Things — leveraging connected devices and real time sensors to improve customer
                                     experience or optimize supply chains

                      Enterprise big data is challenging because the relevant components (data streaming, batch analytics,
                      databases, machine learning) are each themselves complex distributed systems that are difficult to set up,
                      maintain and operate in a 24x7 environment. For enterprises with multiple teams or business units, this
                      means multiple deployments for each distributed system to cover different versions of the technology being
                      used, and different phases of the software development lifecycle — significantly driving up costs for
                      infrastructure, engineering talent and time.

                      Open Source
                      Enterprises increasingly recognize that to be competitive they cannot afford to start from the ground floor
                      when building new systems. Many of the modern enterprise application components described above each
                      have their own ecosystem of open source projects and companies behind those technologies. Enterprises
                      successful using these technologies together dramatically accelerate their pace in developing new services.

                            Modern Enterprise App Components             Technologies (not exhaustive)

                            Container                                    Rkt, Docker, Mesos

                            Databases                                    Cassandra, Elasticsearch, MySQL, Redis, Postgres

                            Analytics                                    Spark, Hadoop MapReduce, Flink, Storm

                            Message Queues                               Kafka, RabbitMQ, ActiveMQ

                            File System                                  NFS, HDFS

Copyright © Mesosphere, Inc. 2016                                                                                        WHITE PAPER | 7
Modern Enterprise Apps Operations With DC/OS
Modern Enterprise Apps
                                                                                                                        Operations with DC/OS

                      Modern App Engineering and Operations
                      During 2010, Twitter was facing an urgent challenge as it could not
                      scale its service to meet the demands of its explosive growth of
                      users. The Twitter “Fail Whale” became an iconic image served up
                      to users whenever the beloved service was beyond capacity.

                      Twitter engineers understood that re-architecting Twitter’s
                      monolithic app into microservices would enable the service to
                      scale, and provide additional benefits — the challenge was how. As
                      Twitter moved to a microservices-based architecture, they had to
                      solve the engineering challenges that now face every enterprise
                      looking to deploy modern apps.

                      Engineering Challenges of the Modern Enterprise App
                      As enterprises move to a modern app architecture, they face several challenges as the infrastructure and
                      operating model of the IT organization also needs to transition to support the modern enterprise app.

                           ●   Deployment complexity — While monolithic apps can be launched and monitored by a single
                               administrator, there simply aren’t enough admins to launch and monitor all of the decomposed
                               services needed by a modern app.

                           ●   Partitioning — A large number of microservices means many partitions of machines within the
                               infrastructure—one for each service—and tracking which partitions are being used by which services.
                               Or, it requires a new architecture that does not need partitions.

                           ●   Extremely low utilization — Infrastructure is typically configured for peak expected demand for each
                               service, wasting hardware, power and cooling, and hardware administration time.

                           ●   Maintaining high availability — There is a severe loss of capacity when services in static partitions
                               fail, and a labor-intensive process of knowing which services need to be restarted or recovered.

                           ●   Configuration and snowflaking — Many services used by the application are distributed systems, and
                               specific versions of each services may be used. The result is partitions that can only be used with one
                               application.

Copyright © Mesosphere, Inc. 2016                                                                                        WHITE PAPER | 8
Modern Enterprise Apps Operations With DC/OS
Modern Enterprise Apps
                                                                                                                         Operations with DC/OS

                      Resource Management Challenges
                      A key problem behind the infrastructure engineering challenges is datacenter resource management. Many
                      modern enterprise app components can be distributed systems, each with their own scheduling logic or
                      characteristics in resourcing requirements. For example, the Spark data processing service may want all the
                      capacity it can get to finish a job. The Kafka message queue may need resourcing based on the volume of data
                      passing through, while the Cassandra distributed database may need steady resourcing to persist data.
                      Therefore, a key requirement for the infrastructure in running modern apps is being able to manage all of this
                      — stateless, stateful and multi-service applications.

                      Hyperscale Computing vs. IaaS Operating Models
                      The challenges mentioned above effectively led to the development of hyperscale computing. While
                      Infrastructure as a Service (IaaS) has made a tremendous impact in enterprise datacenters by virtualizing
                      physical servers into logical virtual machines, many of the gains enabled by virtualization to improve
                      efficiency and availability (e.g., workload pooling, high availability, fault tolerance) are VM-centric and cannot
                      be applied to modern enterprise applications, which are highly dynamic and span multiple machines.

                      Besides being slower than containers, traditional VM-based infrastructure clouds can’t meet the modern
                      enterprise app operations requirements for two main reasons. First is that running microservices in VMs
                      means proliferations of VMs, overwhelming administrators that need to manage them – even with the use of
                      configuration automation tools. Second, is that VMs effectively partition servers, but what’s needed in this
                      new era is aggregation of the datacenter to run multiple distributed systems — each with their own logic for
                      resourcing and scheduling.

                      For Twitter, using modern enterprise apps, powered by Apache Mesos — the core of datacenter operating
                      system technology — enabled the company to manage the unprecedented scale of users, while also improving
                      manageability, rolling out new services quickly, and running at higher utilization.

Copyright © Mesosphere, Inc. 2016                                                                                         WHITE PAPER | 9
Modern Enterprise Apps Operations With DC/OS
Modern Enterprise Apps
                                                                                                                       Operations with DC/OS

                      The Datacenter Operating System Model
                      The Datacenter Operating System (DC/OS) model was conceived with the disruptive idea that running
                      datacenter-scale services should not be more complex than using a single computer. DC/OS aggregates
                      primitive infrastructure services so that both the developer and the operator work with a single form factor:
                      the logical datacenter. In addition to providing elastic scalability for distributed systems, DC/OS ensures high
                      availability and fault tolerance of services.

                      A user running an app on her PC does not care about which CPU core the application will run on, nor does she
                      care whether the app is taking up one or two cores. The PC’s operating systems manages this for her. The
                      Datacenter Operating System (DC/OS) model applies this basic principle to the full logical datacenter. There
                      are two key differences. First, the form factor that the user engages with is the complete logical datacenter (as
                      opposed to a PC). Secondly, apps running on DC/OS are not monolithic apps running on a single PC — they are
                      Modern Enterprise Apps made of distributed systems of stateless and stateful services.

                      Developer and Operator Experience
                      With a DC/OS operations model, developers and administrators do not need to care about which CPU core will
                      be running applications they’ve launched, for any core in the logical datacenter. DC/OS commands are issued
                      against the full logical datacenter in the DC/OS command line or GUI. This model has several benefits for
                      developers, operations, and the hurdle for specialized skills.

Copyright © Mesosphere, Inc. 2016                                                                                       WHITE PAPER | 10
Modern Enterprise Apps
                                                                                                                       Operations with DC/OS

                      Developers code against the logical datacenter, spending more time on application code and spending less
                      time on datacenter plumbing. The “datacenter developer” builds distributed systems that can dynamically
                      leverage all the resources available in the datacenter, with DC/OS handling actions like task management,
                      deployment, resource allocation, isolation and quality of service.

                      Operators in a DC/OS model run the logical datacenter using policies, and do not spend time managing
                      individual machines (physical or virtual), dramatically reducing time and effort. A key benefit for operators is
                      the ability to run at high levels of utilization, even as demand from multiple distributed services changes over
                      time.

                      But the largest benefit of the DC/OS model is perhaps reducing the technical skills hurdle for running modern
                      apps. With DC/OS, complex distributed systems like Spark, Kafka, Cassandra and many other services become
                      dramatically easier to install and operate. Single commands in a DC/OS UI can launch datacenter-wide
                      services, scale those services and maintain those services. DC/OS effectively applies prescriptive best
                      practices in running these services, based on the production operational experience of others.

                      Apache Mesos the Enabling Technology
                      The core of DC/OS is the Apache Mesos distributed systems kernel. Its power comes from the two-level
                      scheduling that enables distributed systems to be pooled and share datacenter resources. Mesos provides the
                      core primitives for distributed systems, such as resource allocation, isolation, and quota management.

                      As a kernel, Mesos was designed with the expectation that additional services need to be built to leverage
                      Mesos’ primitives. These are the components of DC/OS, such as security, advanced networking, operations, as
                      well as other capabilities that make DC/OS a full operating system for the logical datacenter.

Copyright © Mesosphere, Inc. 2016                                                                                       WHITE PAPER | 11
Modern Enterprise Apps
                                                                                                                       Operations with DC/OS

                      Platform Considerations for Modern Enterprise Apps
                      For many enterprises, the transition towards modern enterprise apps is gradual, and their infrastructure will
                      need to run traditional apps alongside modern apps.

                      Only the DC/OS model enables operators to run all modern enterprise app components (microservices,
                      stateful big data storage and analytics) while having the flexibility to run traditional apps. The DC/OS model
                      uses the full logical datacenter as the unit of abstraction, aggregating infrastructure services to run modern
                      enterprise apps — DC/OS is built to operate the application whether it runs on a single node or is a distributed
                      system of microservices, containers, and stateful and stateless services.

                      Infrastructure as a Service (IaaS) models essentially provide virtual machines on demand, with the virtual
                      machine as unit of abstraction. While virtual machines have had tremendous impact in eliminating physical
                      server management and improving traditional workload efficiency and manageability, the virtual machine-
                      centric model is not suited for modern enterprise applications composed of distributed services.

                      Container as a Service (CaaS) models, or container-centric management platforms, use the container as the
                      unit of abstraction. CaaS’s meet some of the needs but fall short overall because running modern enterprise
                      apps goes far beyond launching containers. For example, CaaS models cannot automate scheduling and
                      perform workload lifecycle management for advanced distributed apps such as databases. Additionally,
                      without a two-level scheduling architecture, stateful big data services cannot be deployed elastically, and
                      managing failures of these stateful services also become a challenge.

                      Platform as a Service (PaaS) models are essentially aimed at supporting developer workflows, not operating
                      applications. PaaS’s focus primarily on building stateless cloud-native applications. Because modern
                      enterprise applications include both stateful and stateless components, PaaS’s by themselves cannot
                      effectively serve as the infrastructure for modern enterprise applications.

                                            Traditional Apps                                     Modern Apps

                        Operating      Stateful, Non-distributed
                         Model               Applications                  Microservices       Big Data Storage     Big Data Analytics

                          DC/OS                   Yes                           Yes                   Yes                   Yes

                                                                                                Some — static
                                            Some — static                                        partitioning,           Some —
                           CaaS                                                 Yes
                                           partitioning only                                    manual failure          not elastic
                                                                                                management

                           IaaS                   Yes                           No                    No                    No

                                                                                Yes
                           PaaS                    No                                                 No                    No
                                                                          (stateless only)

                      IT Operating Models and Supported Capabilities

Copyright © Mesosphere, Inc. 2016                                                                                       WHITE PAPER | 12
Modern Enterprise Apps
                                                                                                                       Operations with DC/OS

                      DC/OS Model Business Outcomes
                      The Datacenter Operating System model applies lessons learned from production, at-scale implementations
                      of the Apache Mesos distributed systems kernel. Common enterprise business outcomes from using DC/OS to
                      power modern enterprise applications include:

                           ●   Hyperscale Operations — Efficiency, automation, reliability and scale of a Google-like infrastructure
                               without the complexity and specialized expertise

                           ●   Developer Agility — Accelerating time to value of new services

                           ●   Data Agility — Enabling applications and services that can capture value from ubiquitous data

                      Hyperscale Operations
                                Every company is a software company, and enterprises with the DC/OS model get hyperscale
                                infrastructure adaptable to new technologies, without requiring an engineering department with
                                the size or expertise of Google. With DC/OS, enterprises can rely on an open production-proven
                      platform, run a mix of traditional and modern apps, provide administrators the greatest flexibility and
                      empowerment, and use a platform that is at its core, future-ready.

                      The distributed systems kernel at the heart of DC/OS (Apache Mesos) has been production-proven for over five
                      years in datacenters of web companies running at massive scale (in order of tens of thousands of nodes).
                      DC/OS provides a highly available architecture with no single point of failure. DC/OS’s native container
                      orchestrator (Marathon) has similarly been proven in production.

                      DC/OS enables a single flexible infrastructure for the full range of enterprise applications, from traditional to
                      modern enterprise apps. Two properties make this possible — first, DC/OS only requires apps run on any
                      modern Linux distribution (with Windows support in the near future), and has an extensible two-level
                      scheduler design. Two-level scheduling essentially allows stateful and distributed services to apply their own
                      business logic for needed infrastructure capacity, while still protecting the quality of service for other
                      workloads. This approach includes today’s distributed systems (e.g., Spark, Kafka, Cassandra) as well as those
                      yet to come, as new technologies can be adopted to DC/OS services.

                      A key benefit with the DC/OS model is running workloads with very different latency needs. For example,
                      DC/OS can run workloads with tights SLA’s (e.g., real-time transaction processing) along with latency-tolerant
                      or less time-sensitive workloads (e.g., transcoding streaming media, batch analytics), driving extremely high
                      utilization while meeting workload service level requirements.

                      The most important benefit for DC/OS is empowering operators and administrators responsible for running
                      the infrastructure. First, as an open source project backed by dozens of leading companies using DC/OS in
                      production, enterprises have the flexibility of running their infrastructure on open source software, and the
                      confidence of knowing DC/OS applies the lessons learned from production experience. Second, DC/OS
                      enables operators to perform datacenter-wide actions with single commands (as opposed to managing
                      individual hosts, virtual machines, or containers). Third, DC/OS automates many of the responsibilities of IT
                      operators, including monitoring, application health checks, auto-recover in case of failure, and applying
                      dynamic scaling policies. Most importantly, DC/OS supports non-disruptive upgrades to the infrastructure.
                      Lastly, DC/OS enables a single operating experience — from on premises infrastructure to cloud-based
                      services, the operating experience is identical.

Copyright © Mesosphere, Inc. 2016                                                                                       WHITE PAPER | 13
Modern Enterprise Apps
                                                                                                                       Operations with DC/OS

                      Developer Agility
                                Businesses using the DC/OS model dramatically improve time to value of new services in two ways.
                                First, by enabling the teams to roll out new services quickly and continuously refine these services
                                across all relevant functional teams — sometimes described as “DevOps.” Second, by enabling
                      teams to experiment with new technologies at will, so they can find the right services (e.g., a new open-source
                      message queue or analytics engine) to power their application.

                      DevOps is an operational and cultural model where teams work cross-functionally to ensure as new services
                      are developed they are also operational in a predictable and maintainable way. Key enablers for this model
                      are automation tools for continuous integration and continuous delivery (CI/CD):

                           ●   Continuous integration — frequently merging developer code to a shared mainline repository
                           ●   Continuous delivery — ensuring mainline code is always in a state that can be deployed to users

                      A common challenge for enterprises is scaling out CI/CD platforms and ensuring enough capacity to build the
                      code for testing prior to release. In many instances, different development teams have their own CI/CD cluster
                      because these platforms are often difficult to scale out to other teams, or teams use different versions of
                      toolchain components. One team may be running out of capacity to build code while other teams’ clusters sit
                      idle. Under a DC/OS model, CI/CD platforms can be easily scaled with simple datacenter-scale commands, and
                      DC/OS’s elastic scheduling capability enable dev teams to share resources through build-bursting.

                      Enterprises recognize using open source technologies is key to developing new services quickly. A developer
                      may hear of a new open source technology at a meetup and decide to try it. She might spend several weeks
                      trying to understand the technology, find the right folks to set it up, research best practice implementations,
                      and configure it given she can find an environment — taking several weeks before she uses the technology
                      with her app. In a DC/OS model, popular open source services are part of the DC/OS Universe, or ecosystem.
                      Developers can use a service by installing it with a simple command against the datacenter, while isolation,
                      security and access controls ensure production systems are not impacted.

                      Data Agility
                                For enterprises, the difference between success and failure in the mobile cloud era is the ability to
                                capture value from actionable insights — all enterprises are already collecting vast amounts of data.
                                Using DC/OS, big data becomes significantly easier to use and integrate with applications, the
                      infrastructure is more performant in processing big data, and developers have the flexibility to adapt the next
                      generation of big data services.

                      Modern enterprise apps need to ingest, analyze, and store data, and present insights to users or trigger
                      actions. Data scientists may also use some of the same services in analyzing data. In the traditional approach,
                      data engineers or developers might research a set of open source technologies and pull together relevant
                      experts, and arrive at a non-production configuration useful for R&D several months later — leaving
                      production readiness for the next phase. DC/OS enables data engineers and developers to install and run
                      these services with simple commands with no engineering work, as DC/OS services are built with best
                      practices. When it’s time to build modern enterprise apps with these services, and later pass them to
                      operations — all can run on the same DC/OS platform, which runs both stateless and stateful services.

                      DC/OS infrastructure is more performant running big data due to elastic and fine-grained resource sharing.
                      Successful enterprises have been able to run their datacenters at over 95% utilization, prioritizing latency-
                      sensitive production workloads, and running batch analytics with remaining capacity.

                      Lastly, the DC/OS services model enables enterprises to easily deploy and use new distributed stateful
                      services. Apache Spark began as a project built on Mesos to demonstrate Mesos’ power. Other big data
                      services like Apache Flink and Apache Storm can also be DC/OS services and benefit from resource pooling
                      and applying best practices implementations.

Copyright © Mesosphere, Inc. 2016                                                                                       WHITE PAPER | 14
Modern Enterprise Apps
                                                                                                                         Operations with DC/OS

                     Transitioning Towards the DC/OS Operating Model
                     Enterprises implementing the DC/OS model have different approaches based on their organization and
                     operational readiness, as well as infrastructure needs. Even as modern enterprise apps play an ever increasing
                     role in IT organizations, most existing applications in enterprises today are traditional, and will continue to
                     play a role. The dual need to provide traditional services while also tackling value-driven customer-centric
                     services has led to the proposed bifurcation of IT operating models.

                     Gartner calls this “Bimodal IT”3 — two modes of operations, each with implications for technology, talent, and
                     operating models. McKinsey & Company shares a similar point of view proposing a “Two-speed IT
                     architecture4” to help enterprises balance two concurrent objectives.

                     Bimodal IT as defined by Gartner:

                          ●    Mode 1 Goal: Reliability — Best price for performance, with plan-based governance, waterfall
                               delivery model, built using enterprise suppliers, resourced with talent good for conventional
                               processes and projects, with a culture that is IT-centric and removed from the customer

                          ●    Mode 2 Goal: Agility — Focused on revenue, brand, and customer experience, governance that is
                               empirical and continuous, agile delivery model, built using small (innovative) new vendors,
                               resources with talent good for new and uncertain projects, with a culture that is business-centric and
                               close to the customer

                     While the modern enterprise app delivers agility and facilitates capturing business value, it is very likely that it
                     will also become the model for “Mode 1 IT” applications over time. Enterprises rolling out DC/OS today fall
                     into a range of adoption patterns.

                     The first is a greenfield model where the enterprise is rolling out customer-facing services based on the
                     modern enterprise app, and recognizes the need for a next generation infrastructure and operating model.
                     Here, modern enterprise apps are being developed and operated entirely on DC/OS environments.

                     In a second model, the enterprise is already running silos of big data and microservices environments, and
                     rolls out DC/OS in phases. First to transition to DC/OS are often the stateless microservices-based apps,
                     followed by analytics, followed by more complex stateful services. This enables engineering champions to
                     demonstrate the impact of DC/OS as they syndicate with additional business units or application teams.

                     The third and most conservative approach is one where workloads are transitioned to DC/OS, but running as
                     statically partitioned to start. The rationale here is to give comfort to stakeholders who want to know where
                     their workloads are running. The immediate benefit is a more scalable infrastructure, with the long term goal
                     of enabling elastic scaling when the organization is ready.

                     3
                       Gartner - http://www.gartner.com/it-glossary/bimodal/
                     4
                       McKinsey Business Technology. December 2014 - http://www.mckinsey.com/business-functions/business-
                     technology/our-insights/a-two-speed-it-architecture-for-the-digital-enterprise
Copyright © Mesosphere, Inc. 2016                                                                             WHITE PAPER | 15
Modern Enterprise Apps
                                                                                                                       Operations with DC/OS

                      Conclusions
                      The modern enterprise application, composed of microservices, containers, and stateful big data services, is
                      key for enterprises to capture new value chains in the mobile-cloud era. The Datacenter Operating System
                      (DC/OS) model is unique from IaaS, PaaS, or CaaS in that only DC/OS is fully capable of running all the
                      components of the modern enterprise app.

                      DC/OS is based on technologies that have been proven in production at scale, and engineered based on
                      established distributed systems production best practices. Mainstream enterprises using DC/OS gain from
                      these built-in best practices, and have the flexibility of using an open-source platform that gives their modern
                      enterprise app complete flexibility on where they run - on premises or in the cloud.

                      For enterprises moving towards microservices, containers, stateful services and open source software, DC/OS
                      reduces the skills and effort required to be successful. The result is broader adoption of these technologies
                      and faster capture of the impact these technologies deliver.

                      About the Authors
                      Benjamin Hindman is a Founder and Chief Architect at Mesosphere where he leads a team building out core
                      services for the Mesosphere Datacenter Operating System (DC/OS). Ben co-created Apache Mesos as a PhD
                      student at UC Berkeley before bringing it to Twitter where it now runs on tens of thousands of machines
                      powering Twitter's datacenters. An academic at heart, his research in programming languages and distributed
                      systems has been published in leading academic conferences.

                      Edward Hsu is the Vice President of Product Marketing at Mesosphere, leading a team responsible for product
                      go-to-market and helping enterprises to realize business outcomes with DC/OS. Ed was previously Sr. Director
                      of Product Marketing at VMware, responsible for EVO hyper-converged infrastructure, vCloud Suite private
                      cloud software, and pricing and packaging for vSphere and the majority of VMware products by sales. Ed
                      spent five years at McKinsey & Company serving senior executives in Fortune 500 companies in the high-tech,
                      banking, and pharmaceutical industries, mostly in IT and service operations functions.

Copyright © Mesosphere, Inc. 2016                                                                                       WHITE PAPER | 16
You can also read