Heat and the Simple Profile

[Zane Bitter <zbitter@redhat.com>]

Greetings,
For those of you who don't know me already, I am one of the core 
developers of the OpenStack Orchestration (Heat) project. I've been 
observing the work of the TOSCA TC since around the beginning of the 
year, and I wanted to take the chance to help y'all get to know Heat a 
bit better so we can all figure out where it fits in to the picture with 
respect to the TOSCA simple profile.

There was some discussion at last week's TC meeting over whether there 
ought to be a bijective mapping between TOSCA's YAML Simple Profile and 
Heat Orchestration Templates (HOT). A couple of interesting points came 
up in the discussion:

Matt mentioned that Heat does not attempt to do "modelling". To my mind, 
modelling is what Heat does - though, I confess, poorly on occasion. The 
caveat is that we are only trying to model concrete classes of 
infrastructure that actually exist in OpenStack (e.g. an OpenStack 
Compute server), rather than general classes (e.g. any server). So I'd 
like to learn more about what "modelling" means in the TOSCA context to 
find out if that is indeed the source of our differing definitions.

Matt also mentioned that Heat doesn't attempt to support an "instance 
model". If I understand the terminology correctly, this is a 
straightforward misunderstanding. Heat is not a fire-and-forget service 
for merely _launching_ cloud applications; it maintains a record of the 
template and the resources it has created (a "stack" in Heat 
terminology) and orchestrates modifications to the template over time. 
The OpenStack Orchestration mission statement is to manage the entire 
lifecycle of the application, and this actually works pretty well today.

The question arose (I think from Frank?) of whether you would be able to 
move an existing application from one cloud to another. This is a good 
question, but in my view it does not depend on a bijective mapping. Just 
as you can't take a running application on OpenStack and relaunch it on 
another (or the same) OpenStack cloud using Heat without first having a 
Heat template for it, nor would you be able to do the same for TOSCA. 
Users will have to define their application at the level of generality 
they want (at TOSCA level - use a TOSCA template; at Heat level - use a 
HOT template).

By "can't" here, I mean "impossible in theory" (to reverse-engineer a 
template from a running application). In practice you could probably 
implement some pretty decent heuristics, but I would prefer not to go 
down that path in Heat.

An interesting related feature that is being implemented in Heat as we 
speak is stack abandon/adopt. When Heat abandons a stack, it will delete 
its "instance model" (so the stack is no longer managed by Heat) but 
output a representation that can be used to re-adopt it again later. 
This provides a path by which users could, in theory, retrospectively 
write a template for some running application and place it under Heat's 
management. (In practice I think this would be error-prone if done 
manually, but it does provide the hook needed for some external tool to 
implement the heuristics mentioned above.)


All of this brings me to one idea of where the distinction between HOT 
and TOSCA could lie. Heat, as it stands, has a very concrete mapping 
between the template and the stack that is produced from it. I see TOSCA 
as more constraints-based, where the template describes the set of 
possible solutions. So one way to look at this would be that a TOSCA 
engine is a constraints solver that produces a concrete model of the 
final result, expressed in HOT. From a debugging perspective I like the 
idea of having an intermediate language that describes exactly what you 
should get, in addition to the tremendous value provided by a layer that 
expresses only in general terms what you need. In the very short term, 
it is probably inevitable that any integration between Heat and TOSCA 
will take this form, simply due to current limitations in Heat. In the 
long term I want to emphasize that this is just an idea I have been 
floating, and is very much open for discussion.

If anyone has further questions about Heat, you are more than welcome to 
ask them either here or on the openstack-dev mailing list (put "[heat]" 
in the Subject line). I'll be sticking around to try to further my TOSCA 
education :)

cheers,
Zane.