What makes a PaaS a PaaS?
I’ve seen many discussions on blogs and twitter around this topic, so much so that many people are tired of talking about it because it always leads to cyclical discussions. I for one haven’t been satisfied with any of the answers that I have seen. Some people try to define PaaS with requirements such as it must be on demand, while others say that an API and services need to be exposed. I disagree with these requirements/constraints on describing PaaS. I think there is a model should be applied to define what is PaaS, to make this model credible there is a necessity that it can be mapped to most (if not all) current and future offerings defined as PaaS (Which will be a follow-on series to this post).
The PaaS Model
The PaaS Model is made up of two different constructs, which are called Spaces. These two Spaces serve different purposes, but are composed of the same PaaS Element Types (elements will be explained in detail, in an App Space deep-dive follow-on post). The Control Space and App Space are show in the diagram below, notice that the App Space is fully wrapped/contained within the Control Space.
The Control Space performs all of the automation, management, provisioning that is required by the PaaS. Interaction with other lower level components such as an Orchestrator is achieved through API abstractions if/when necessary. The Control Space and its implementation also determine what elements are allowed/exposed to the App Space. Further, the Control Space is responsible for maintaining App Space coherency and dependencies. While the Control Space is comprised of several separate functions, they may be combined in different manners depending on the specific PaaS implementation. All of this will also commonly be exposed through one or more API interfaces (this however, isn’t necessarily a requirement in the model presently).
The App Space is where end-user/customer applications are deployed, updated, and run. The App Space is controlled (and commonly coordinated) by the Control Space. The exposure of PaaS Element types by the Control Space to the App Space is one of the key differentiating factors between different PaaS implementations. App Space characteristics are controlled by how the Control Space is built/designed along with what PaaS Elements were used to build the Control Space.
- App Network: The path which applications communicate with app each other and services/resources exposed to apps. The App Network exposes Network connectivity to the App Space.
- Executor: The application bootstrapping mechanism for apps being or currently deployed. The executor provides compute/memory resources to the App Space.
- Code Processor: Examines code, libraries, and dependencies before sending to the Engine and/or Executor. This can also be thought of as a code inspector or post/pre-processor.
- Coordination Network: Where the Control Space components communicate/coordinate with each other. Think of this as a management network that is in most cases out-of-band from the App Network. The Coordination and App Networks could be combined, however in a production system this would introduce too large of a security risk.
- Engine: Coordinates the distribution and provisioning of code, services, and their dependencies (most frequently in the Control Space). The Engine decides the where and how of what happens in the App Space. Also, the Engine may be capable of coordinating with an Orchestration Layer or other automation tools outside of the Control Space to provide new/additional resources to either/both the Control Space and the App Space.
- Monitor: Looks at the state of the App Space and the Control Space, signaling other Control Space components to resolve conflicts. The component most likely to resolve conflicts would be the Engine or a specialized component designed purely for conflict resolution.
- Notes: These components/functions may be grouped differently based on the specific PaaS implementation. Also, some of the functionality or components could be put into an API, split into sub-components, or even externalized through/in a Client or Client side API.
PaaS Elements are abstractions on top of different layers of resources. Most PaaS Element abstractions are done through Service based or Service centric abstractions. This is not the only way of creating/doing an abstraction, but it is one of the most flexible ways. PaaS Elements are broken up into three primary types which are defined below:
Please note there will be an in-depth post on PaaS Elements following this blog post.
- Primitives : The Core Building Blocks of Resources
- Sophisticates : Composites / Combinations / Extensions of Building Blocks (Primitives)
- Definitives : Instantiations of Primitives and Sophisticates either directly in use or wrapped in Services/APIs
All PaaS Elements have the ability to provide or interact through a pass-through interface or abstraction to any other PaaS Element type all provided by the Control Space. Elements are combined to create an Application (App) in the App Space. The most interesting twist to the model is that the Control Space is made up entirely of PaaS Elements as well. There is a great deal more to be covered on this topic both here on this blog and out in the community. Please provide feedback and questions in the comments section of this post or live on Twitter (@mccrory)