DevOps in a Modular World?
IT automation tools are increasingly necessary. They help manage planned changes and automate repetitive tasks; and they can provision and configure, orchestrate and scale, traditional applications in on-premise or Public cloud environments. An increasing number of these ‘DevOps’ tools are model-driven; meaning that the desired structure is defined in a model and the runtime automatically drives to deliver this.
Most ‘DevOps’ tooling has emerged to deal with traditional applications: ‘coarse grained stacks’ of monolithic software. However, for organizations pursuing Agility:
- Microservices based architectures are a compelling choice. The implications of which are that the runtime environments become increasingly decentralized with a greater variety of distributed runtime applications; each often with differing requirements from the underlying infrastructure.
- The development process becomes increasingly Agile leading to the software artifacts becoming increasingly fine grained.
- Waterfall development and deployment is replaced by Continuous Delivery and Deployment, rapidly increasing the flow rate of artifacts into Production.
The Service Fabric has been designed to meet these challenges.
Meeting The DevOps Challenge
The Service Fabric is a highly automated, adaptive, model-driven platform that directly addresses the issues of simultaneously deploying and maintaining traditional monolithic applications and diverse sets of highly modular Microservices-based applications (Systems) and their dependencies, across in-house data centers and Public Clouds.
- Self-Describing: Each Fabric hosted application is described in terms of a ‘System’ description (the model).
- This model completely describes the runtime structure of the application, so the application is self-describing and Governance and Regulatory requirements are automatically addressed.
- Different Systems may be rapidly composed from the same functional components to deliver different runtime topology and scaling behaviors.
- Dynamic Assembly: Using the model, the Service Fabric automatically assembles, configures and creates the desired applications and services on the most appropriate resources available. From the simple deployment and configuration of a traditional application to a specific host, to the complex dynamic assembly of a Microservices based application or system across 100’s, 1000’s or 10,000’s hosts.
- Semantic Versioning: All Systems and artifacts are semantically versioned. The Fabric enforces this contract in Production, providing strong Governance and Regulatory guarantees. Removing the need for a CMDB or for audits of deployed software.
- Dynamic Updates: Software updates are applied by releasing the updated version of the ‘System’ model. The Fabric applies the updates, only for the relevant components, wherever they are deployed. Roll back to a previous System version is as simple and rapid.
- Software-Agnostic: The ‘System’ model may be comprised of highly modular OSGi based components, or traditional coarse-grained software, or both. Software components may be written in a JVM based language (e.g. Java / Scala) or native e.g. C / C++.
- Multi-Tenancy: Multiple Systems may be hosted by the same Fabric. Each System may have very different middleware, data and runtime resource requirements, and the Fabric will ensure the relevant resources and middleware are used and the services are provided.
- Dynamic Recovery / Adaption: The Service Fabric expects, and automatically handles hardware failures without Operator intervention. If resources allocated to it fail, or if more suitable resources become available, the Service Fabric automatically re-deploys and re-configures affected components. Optionally, once an infrastructure issue has been resolved, the Fabric will rapidly re-balance components to optimize performance.
- Self-Healing: The Service Fabric’s own internal infrastructure is automatically maintained across the distributed environment. There are no single-points of failure and the Service Fabric automatically adapts as the population of resources changes over time.
- Scale-Out: Scale-Out and load-balancing behaviors may be composed into the application’s System model with no change to business logic. At runtime, the Service Fabric transparently handles scaling and load-balancing.
- Roles Based Management: Via ‘Paremus Entire’, the Service Fabric Management Interface, Operators, Fabric Administrators and Management are provided with role based views and access into each Fabric running in the organization’s environment.
Built upon OSGi, the open industry standard for modular software, the Paremus Service Fabric simplifies and automates the process of dynamically deploying and managing both the traditional monolithic applications and the new breed of highly modular Microservice-based applications.
What about Virtualization?
Over the last decade most established IT vendors have suggested that Enterprise issues can be addressed with virtualization and / or Cloud. They are mistaken. Virtualization only addresses the question of hardware utilization, which in reality is not the significant cost overhead in today’s organisations.
VM-based environments usually treat the runtime artifact, the Virtual Machine Image, as the unit of deployment. Unfortunately this is a monolithic, opaque and ill-defined software entity. Recent trends such as the Docker Container re-establish the concept that runtime modularity is necessary at least at the level of the traditional application. However this does nothing to address the inherent problems of the traditional monolithic application structure.
An additional concern is that naive use of Virtualization or Software Defined Data Centre (SDDC) technologies hide the realities of the physical environment within which each application runs. This increase the runtime’s environmental complexity, which in-turn increases both management cost and operational risk.
Rather than hiding the physicality of the environment within which an application runs, the application needs to be aware of, and adapt to, the realities of the physical and virtual resource which are available within its host environment. The Service Fabric achieves this objective, preserving the advantages of your virtualized infrastructure while addressing the associated management issues and operational costs.