A light weight RDF and OWL should work here. There are at least three vectors – the representation, exchange semantics and a processing model. If we keep them lightweight, OWL-Lite should work; I do not think we need the decidability and completeness. Moreover, we are aiming at capturing the relationships between VMs, attributes and related artifacts. In the worst case, we can always use microformats (which works well with XMPP)rather than a mungo XML Schema.
Just m 0.02$
I don’t see anything wrong with the ideas of schemas fundamentally, though I think one of the challenges that we’ll find is that with such a broad focus of this group – focusing on lots of very different types of cloud infrastructures – keeping schemas from becoming very unwieldy will be a challenge.
I think there’s three main considerations:
- Readability/specificity – making sure that whatever is written down is easily understandable, given the wildly disparate models we’re looking at. There’s a lot of open standards that fell apart in related areas (DCML, etc.) due to the weight of the
- Simplicity of technology stack – whatever protocols are used should be easily implemented – something XMPP or REST-driven have lots of libraries that abstract some of the complexity at a protocol level, I know a lot less about dealing with RDF (I realize you could do RDF-over-just-about-anything, I’m just less familiar with RDF). We should keep that in mind to make solutions as easy to implement as possible
- Minimizing required implementation – Along similar lines to the previous two, if there’s one knob that you want to twiddle across disparate environments, you should ideally have to only implement that one knob with a minimum of scaffolding
Based on those considerations, the last one is very well suited for SNMP/object model type activities, but very strict object representations have been shown in SNMP to be very ugly, and also not cleanly handle bi-directional communications, state models, etc. RDF looks elegant, but I would have to know more about the types of activities we’re trying to integrate.
Perhaps a set of simple schemas for different classes of activities might fit in the middle. I think it’ll be important at some point soon to define some user stories & scenarios and try to see which models we might fit within.
My post the other day about creating an XMPP based unified cloud interface has generated a lot of interest (Thanks you Dave @ Cnet). One point that has been mentioned by several people is in regards to the proposed usage of a XML schema and whether a predefined model makes any sense. A few of you also said to look at a more "RESTful" architecture, which in my opinion is not mutually exclusive to a XML schema. Several have pointed me to the SNMP protocol and its object model, as a good example. SNMP uses a strict verb discipline in tandem to the protocol's small operator set, and the 'resources' are addressed with a uniform global scheme of Object identifiers.
So, it seems like there’s some general consensus that it makes sense to KISS and spec before we go nuts deciding protocol specifics. Where do we go from here? What do people see as the general areas for investigating first?
Users at Cloudcamps have pretty clearly outlined a great deal of what they want to see standardized in the cloud. A common control interface. Code portability. Data portability. Common security. Inter-cloud communications.
If I read your objective correctly, you're focused solely on the first of these - the control interface. However, I don't think it's possible to create a really well thought out extensible control interface that'll stick without first identifying what it is we're controlling. Are you sticking to just a virtual machine and leaving security, networking and storage to code within the VM? If so, then you'll get portability of the mgmt interface, but not of the actual applications which is what customers actually care about.
IMHO lasting standards usually start with a model, in our case for an application running in the cloud. Internally we use what I call the Facebook test, ie could I run Facebook on this. A proper model will allow us to identify the boundaries that need standardization and the requirements at each of those boundaries. As others have noted, many attempts have been made at this, so there may already be work that can be leveraged.
Then again, I'm just a marketing dweeb . . .
This is very good, though – there’s a lot of analogies here to other attempts to create open standards for vendor-specific platforms:
- resource abstraction – “I should be able to refer to an image as an image, regardless if it’s an AMI, or a slicehost VM, etc”
- reporting/information abstraction – “Regardless of the cloud provider, I should be able to report on my utilization as a common language, to the extent of apples-to-apples comparisons”
- Control abstraction – “I should be able to have a common set of verbs programmatically to interact with like-for-like systems (i.e. gogrid and aws)”
The next level above that I see as driving inter-cloud events without an intermediary or more advanced functionality within a single cloud– this is trickier both from a technical perspective and from a policy perspective (is company A that interested in making it easy to migrate data from them to company B because company B is 15% cheaper?). At that level, you have:
- AAA abstraction – Authorization, Authentication, Accounting – pushing security policies between two different cloud providers
- Data movement – Migration/cloning/duplication/distribution of information across providers
- Policy-based administration – “Based on performance criteria X, perform activity Y” – this is likely to be very very difficult, as these mechanisms tend to be very platform-specific, so I lumped it in the more advanced section
There’s another level above that which is really pie-in-the-sky type things, complete abstraction, dynamic reallocation based on costing, integration to external systems, etc. etc.
But the first set I listed above has been tackled by many people, with varying degrees of success. What other high-level classes of functionality are missing from this?