CloudObjects / Blog / Introducing CloudObjects Core

Introducing CloudObjects Core

In the first article on this blog, “Hello World!”, I said that we believe that “integrating and aggregating APIs and deploying code without managing servers is the way for building software today”. It also means you end up with a lot of building blocks from different vendors. And while the providers of these building blocks promise to make building a website or app as simple as putting LEGO bricks together, managing multiple vendors and integrations becomes a pain in itself. You have to sign up for each of them, create and configure your application with custom integrations and put configuration data such as API keys in different locations of your code.

I also said that “our mission is to simplify and improve the lives of web and app developers by providing them with great tools and helping them discover and leverage cloud services, APIs and other objects from different vendors” but left you with no explanation on how CloudObjects wants to do that. Today I’m very excited to introduce our very first building block, the first small step on this mission: CloudObjects Core.

We thought: “What if there were a formal model to describe a modern cloud-scale deployment of a digital product? What if we could write a specification that maps out a product and includes the entire configuration of all components and their relationships?” So we looked around and found RDF (Resource Description Framework), a data format that was designed for the Semantic Web. RDF is a great format to describe objects and the relationships between them, especially because the meaning of every property or class is unambiguously defined (through a URI) and we can combine multiple, independently managed namespaces or ontologies. We can also place references to other objects - that’s why it’s called Linked Data. This means one could use RDF combined with the right ontologies to describe, for example, if a service consumes one or more APIs and also include details of the integration which are relevant for the deployment.

With RDF, one piece of the puzzle was found, but the puzzle was not complete. The Semantic Web is about putting public RDF documents out there, but not every bit of information should be public. Some information is only relevant for specific consumers and must not be revealed to others. API keys are just one prominent example of confidential configuration data. Also, there should be some control over the configuration from every party that is involved in it. In the API integration scenario from the last paragraph, for example, I should not be able to make the statement that my service consumes a certain API if that API is only for designated partners and the provider has not approved my usage. Also, API provider 1 should not see information about API provider 2, whereas a facilitator for integration, such as an API gateway or proxy, should see both. Thus, what we need is a way to store configuration data, validate and confirm it with all stakeholders and then distribute the information selectively to different relevant parties and the public. And that is exactly what CloudObjects Core does!

CloudObjects defines its own URI schema with DNS hostnames to group objects into namespaces and allows developers to upload RDF descriptions of their objects using well-defined properties and references to other objects. Those configuration jobs are processed and, if the configuration has been validated, the new or updated objects are securely persisted in our core database. Information is revealed in machine-readable form through APIs and SDKs and in human-readable form on the CloudObjects directory so that both humans and cloud services can fetch and parse the information that has been made visible to them, no matter where they are located, provided they can authenticate themselves. One place for all your configuration data with a built-in distribution mechanism, that’s the big idea!

If all that sounds a bit unspecific or intangible to you for now, fear not! First of all, there’s documentation that unpacks the details about our usage of RDF, the permission system etc.. Also, once we release other CloudObjects products built on top of this core the picture will certainly become clearer. There will also be further blog posts outlining the possibilities and how to use them. At this time, though, we believe that CloudObjects is already a very interesting product for people who love to play around with RDF. We invite the Linked Data / Semantic Web community and all interested individuals to provide us with feedback on our usage of RDF and how it can be improved! We’re also curious about your ideas on building on top of CloudObjects, so feel free to contact us about them, too.

by Lukas Rosenstock