FAQ - CloudBees Extensibility

• General
  • • Why is CloudBees Platform different from other platforms?
    • What are CloudBees extension mechanisms?
    • Are you expecting to add more extension mechanisms?
    • As an Enterprise, how can I benefit from an extensible platform?
    • As an ISV, how can I benefit from an extensible platform?
    • As a SaaS, how can I benefit from an extensible platform?
    • As a Community, how can I benefit from an extensible platform?
    • Are those extension points proprietary? Are they locking me in?
• ClickStart
  • • What is ClickStart?
    • Do ClickStarts require a for-pay account?
    • How can I create my own ClickStart?
    • How can I make my ClickStart available to 3rd parties?
    • Can I make a ClickStart “private”?
    • In which account, does a ClickStart template execute?
• ClickStack
  • • What is ClickStack?
    • I want flexibility in what I run. Shouldn’t I be using an IaaS provider directly?
    • Does ClickStack require a for-pay account?
    • Can I create my own ClickStack?
    • Can I make my ClickStack available to 3rd parties?
    • Can I make a ClickStack “private”?
    • How is a ClickStack different from Puppet or Chef?
    • How is a ClickStack different than ProcFile
    • Can I run PHP/Ruby/Node.js/you-name-it on CloudBees?
    • Does this mean CloudBees is now a “polyglot” PaaS provider?
    • If I create my own or use a 3rd party ClickStack, what is the scope of CloudBees support?
• ISVs/SaaS
  • • As an ISV/SaaS vendor extending the base CloudBees offering, can I extend CloudBees’ default stacks or do I have to provide my own??
    • As an ISV/SaaS vendor, how can I leverage CloudBees Platform?
    • As an ISV, can we use the CloudBees Platform to provide demo versions of our software?
    • Do you provide a way to manage software license keys?
    • Can I bring software XYZ and run it on CloudBees?
    • If a customer uses one of our software, how can we migrate them to a newer version?

General

Why is CloudBees Platform different from other platforms?

To CloudBees, a key criterion that defines a platform is its ability to be extended, customized and adapted to meet a specific need. This has been true of all successful platforms on the market: Linux, Java, Jenkins, etc.

Generally, those platforms feature a minimalistic yet extensible kernel. All platform services are then built around that kernel, through well defined extension points. Those extension points are typically the same that are available to the platform vendor as well as 3rd party developers. In such a scenario, from a platform standpoint, all services running on top of that kernel are equal.  In summary, “if you can’t extend it, it is not a platform”.

A number of PaaS on the market do not provide such a level of extensibility. While they tend to all offer a way to connect with 3rd party services, such extensions are made through statically defined and feature-constrained bridges that do not expose the same level of connectivity that a pluggable platform kernel would.

The CloudBees platform is built around such a platform kernel and has announced at JavaOne 2012 that its first set of extensibility mechanisms have been opened to developers, enterprises, ISVs, SaaS vendors and communities.

What are CloudBees extension mechanisms?

On top of the pre-existing API that can be used to interact with the CloudBees Platform Kernel, an initial set of extension mechanisms have been opened at JavaOne 2012. They include:

• ClickStart: a templating mechanism that makes it possible to aggregate a set of services and commands to quickly get started on a new environment or project;
• ClickStack: a mechanism by which runtime containers can be either defined or inherited-and-extended
• OAuth: a way for 3rd party platform extensions and services to securely closely interact with a platform tenant’s services, applications and resources.
• Account Provisioning: ISVs are able to programmatically create new dedicated tenants for their customers and pre-configure them to match their requirements.
• SDK: The CloudBees SDK, that provides access to the underlying CloudBees API for application creation and all other aspects of the CloudBees Platform, is itself extensible by partners and customers, so the base commands supported by CloudBees can be augmented via plugins.

Are you expecting to add more extension mechanisms?

Yes, more extension points will be opened to the public in the next few months. Those will make it possible for 3rd party providers (communities, ISVs, enterprises, etc.) to implement services that interact and modify even more closely and deeply the CloudBees Platform.

As an Enterprise, how can I benefit from an extensible platform?

As an enterprise, the CloudBees platform makes it possible for you to customize the PaaS to your own needs and processes rather than have your development team be forced into “The CloudBees way” if that is not what you want. Enterprises are able to define their private project templates, runtime environments, services and resources, and UI enhancements (future) so that their developers can get a highly efficient environment and can start new projects in a click, further reinforcing the well known “time-to-market” ability of the CloudBees platform.

As an ISV, how can I benefit from an extensible platform?

As an ISV you have the ability to provide a smooth transition path to the cloud for your customers. If you have a non-Cloud/mono-tenant application that you’d like to expose to your customers as a SaaS, CloudBees can help you achieve this in a painless fashion.
Through the various mechanisms offered by CloudBees, you can “SaaSify” your existing applications and automate their deployment in the cloud for your own end-customers. CloudBees will take care of managing, monitoring and scaling your application, and you’ll focus on provisioning new tenants to your customers.

One way to do this is to make CloudBees totally invisible to your customers and fully automate the steps through the CloudBees API. In this scenario, whenever one of your customers wants to try or use your platform for production, you will programmatically create a dedicated platform tenant for that customer, and provision the entire set of resources and applications that are needed for that customer to use your software, in mere seconds. This environment can then scale from a test-only/non-clustered environment to a highly-scalable, fully clustered environment that could run in multiple regions.

Another way is if you prefer to let your customers directly try and deploy your software in the cloud, on top of the CloudBees platform, with no further work on your side. In that case, you simply need to create a “ClickStart” solution that will let your customers get started on your software on a production ready, fully clustered environment in a single click! ClickStart will provision all of the resources your software requires (applications, databases, pre-populated data, source code, etc.) and deploy your software using your best practices recommendations, without any guessing or trial-and-error from your customers, on their own CloudBees account. You are also able to control versions of your software and cycle your customers to the next release. By leveraging the CloudBees platform architecture, ISVs are able to implement a comprehensive cloud-strategy with no need to worry about any infrastructure or cloud-related worries.

As a SaaS, how can I benefit from an extensible platform?

If you are a SaaS provider, you will quickly realize that there is only so much your users can do with a static set of parameters to customize your SaaS. While for some relatively basic SaaS this can be fine, for others, the inability for a customer to perform deep customizations can limit SaaS adoption rates. Salesforce.com, for example, produced Force.com so their customers could apply deep customizations in the form of APEX code. In the same way, you can now offer a PaaS environment to your SaaS customers, and this PaaS is CloudBees.

By providing the proper extension points in your SaaS and by providing a custom CloudBees PaaS environment (specific ClickStack, ClickStart, SDK and UI customization, etc.) your customers can deploy SaaS extensions structured as Java applications (or some other JVM-based mechanism) deployed on the PaaS itself. And if you don’t want CloudBees to be visible to your users, you can make it “invisible” by wrapping the key workflow your users will use to customize their SaaS and, in turn, orchestrate the real actions on CloudBees through its APIs.

If you are interested in using CloudBees to support the billing/invoicing service for your own SaaS, so you don’t have to setup such complex infrastructure yourself, please contact us for more details.

As a Community, how can I benefit from an extensible platform?

As a community, you’d typically onboard new users for your project by providing a “zip” or “tgz” file for download and a wiki page explaining how to setup and configure your project on a variety of different operating systems and hope those won’t change too much between releases. Yet, the success of your onboarding process will typically be inversely proportional to the time they need to spend before they can see the value of your project.

By providing a “ClickStart” for your project on your download page as an additional option, your community users can get started in mere seconds. By just clicking on that link, a complete development and deployment environment will be setup on their CloudBees account, following the best practices you’ve defined for your project - no guessing, no trial and error, simply the precise environment you have defined in a click.

For example, as part of the ClickStart, you could

• Fork a sample application in a CloudBees Git repository
• Setup a build job in Jenkins (hosted at CloudBees) that will build, test and deploy your app anytime the user performs a “git push”
• Deploy that application into a runtime bucket with an associated database (prefilled with data if needed).
• And if you want, let your users directly modify that code and see the impact of that change in realtime in a browser. They can either use the CloudBees Eclipse plugin or use one of our partners’ IDE in the cloud, such as eXo Cloud IDE, directly opened on the right source code file!

You’ll also be able to provide further extensions to CloudBees to fit the needs of your particular community such as CloudBees SDK extensions (so you can offer specific commands to the users of your project on CloudBees), UI modifications (soon), modification to the runtime container (loading of agents for example), etc.

Are those extension points proprietary? Are they locking me in?

As the PaaS market is still shaping up, many PaaS vendors do not offer a mature extensibility mechanism. Consequently, a community/ISV/etc. that would be using CloudBees extension points would most likely not be able to use them with other providers.

However, as demonstrated through its support for the JCP and to CAMP CloudBees is committed to open standards. As such, CloudBees is committed to work with other PaaS vendors to agree on a common set of extension points and to make any required technology or copyrights for improved interoperability available free of charge. This would make it possible for 3rd party providers, to use multiple PaaS vendors in a standardized fashion.

ClickStart

What is ClickStart?

ClickStarts reduce to a single click everything you need to create and deploy a running application that builds from source, is set up with continuous integration and deployment, and connects to other hosted services.

Because ClickStarts give you a way to specify any or all of the components you want to pull together to support a working build or application, they serve primarily as an accelerator for your development.  Instead of a lengthy README walking users through what they need to do in order to go from source to a working, deployed application, you simply point at the URL of your ClickStart.  CloudBees then prompts you for the minimum information it needs, such as an app name, and everything is up and running in minutes.

In this example, this ClickStart has

• Instantiated a source repository, a Jenkins build and a MySQL database.
• Loaded the source code into the repository
• Established a Java EE 6 Web profile container
• Deployed the application and readied it for its first use

All in one single click!

Do ClickStarts require a for-pay account?

No. ClickStarts only require a CloudBees account, and work fine with free accounts.

However, some specific ClickStarts might ask to provision resources above and beyond the constraint of free accounts. For example, it might require containers with more memory, or to use specific resources that are not available for free. In that case, the user will be asked whether they are willing to instantiate those for-pay resources as part of the ClickStart process. Even in that case, the user could still deploy those for-pay resources for a few hours, and de-provision them later: there is no long-term financial commitment required.

How can I create my own ClickStart?

The simplest way is to fork one of CloudBees’ sample ClickStarts hosted at GitHub and read the associated documentation. The process is pretty straightforward and it shouldn’t take long before your first ClickStart is ready to serve requests!

How can I make my ClickStart available to 3rd parties?

The easiest way is simply to make the ClickStart URL available on your web site or within the README for your project. We also provide a button you can use so people just have to click on it:

You’ll soon be able to register your ClickStart on CloudBees.com so that any user can browse and find your application, without having to visit your web site.

Can I make a ClickStart “private”?

TODO

In which account, does a ClickStart template execute?

While anybody can create a ClickStart and make it available on a public web site, this ClickStart will then execute in the CloudBees account of the developer who clicked on it. If you are not logged yet, you’ll be able to do so and to choose your CloudBees account in case you have multiple accounts. However, you’ll always be prompted before any resource gets provisioned in your account, for example, by clicking on a ClickStart template. No resources will be provisioned on your behalf without your explicit approval, so this is a safe process.

ClickStack

What is ClickStack?

ClickStacks let you customize CloudBees runtimes and compose new runtimes that applications run on.

So, whether you’re a developer wanting a specialized collection of frameworks or runtime, or you’re a large shop looking to deliver a reproducible and manageable stack of components for all your developers, ClickStacks is the PaaS solution.

Many development shops and enterprises have “standard” stacks they work with.  Internally developed code that interacts with existing systems is typically reused across multiple projects.  Large companies often have a team whose responsibility it is to release stacks that they assemble from commercial and open source software. Internal development teams are required to use these pre-approved standard stacks to take advantage of IT support and to speed rollout of applications. ClickStacks deliver the same kind of advantages on the fully managed CloudBees PaaS. ClickStacks let you weave together multiple runtimes using a plugin model.

Because CloudBees-curated plugins in the stack can be woven together with customer-managed plugins, you can rely on CloudBees to keep core parts of the stack up-to-date, while you update your plugins at your pace. You get the same provisioning, monitoring, and scaling capabilities you expect from CloudBees, but applied to a runtime stack you have customized to meet your needs. This plugin model, mixing CloudBees-curated runtimes, together with Partner-managed and customer-managed plugins, fits naturally with existing versioning schemes.

Operations teams may control hosted binaries and libraries that are reused across teams. When teams package their own libraries with an app, the shared mechanisms a company has in place to deal with updates and multiple versions are bypassed, resulting in a maintenance nightmare. Entire software products and services are built around addressing this problem. A PaaS that forces you to choose only from its blessed runtime menu, or that points you toits source code for a solution, is working against proven mechanisms and processes that are important to enterprises. ClickStacks provide a fundamental mechanism that meshes the as-a-service sensibilities of the cloud with the traditional operational approaches that follow established IT policies for assembling standard stacks. CloudBees uses the same mechanism for efficient delivery and maintenance of its own services, so you already know that it works and scales.

I want flexibility in what I run. Shouldn’t I be using an IaaS provider directly?

That’s indeed an option, but most probably a bad one.

Until now, developers who wanted to deploy an application in the cloud were facing a limited set of options.

What they would typically start doing is to build and setup a complete application runtime environment on top of a IaaS provider such as AWS. They’d realize quickly that there is a lot of DevOps work required to do so successfully and that the maintenance of such a complex environment (especially as you start automatic recovery, clustering and elasticity) kills any efficiency and go-to-market gain that were central to the decision of moving to the cloud. The IaaS “do-it-yourself” solution offers extreme flexibility (since what you can do is only limited by your own capabilities) but very little ends-up being outsourced and supported by a specialized 3rd party. Flexible but inefficient and painful.

Then, those developers would move and start using a PaaS solution. While, in such an environment, most if not all of the above problems end up being solved as the runtime environment is fully managed, updated and supported by the vendor, the flexibility of those environments was minimized. PaaS vendors would typically offer a handful of “curated” or “certified” stacks for you to use, which might (or might not) fit your requirements. Fully supported but not flexible.

Some PaaS providers then started offering a hybrid solution: developers were entitled to upload their own software stack along with the PaaS vendor curated stacks. Developers would then face an environment where some of their applications are fully supported and the runtime fully maintained by the PaaS vendor, while, for the other stacks (the ones directly provided by the customer), they were able to benefit from some of the PaaS services (monitoring, some elasticity, etc.) but the content of those images (operating system, middleware container, JVM, etc.) would not be supported at all: the PaaS vendor obviously has no idea what runtime you’re running in those “opaque” images and you are responsible for patching and maintaining those. Better, but not quite a great solution yet.

CloudBees now elegantly solves this problem by offering developers the ability to not just provide their “full custom stack” but, instead, take a standard and supported PaaS vendor curated stack, and weave additions/modifications into that stack. The developer then only becomes responsible to maintain the weaved bits, but doesn’t need to worry about the vendor curated components of the stack: they remain dynamically supported by the PaaS vendor, without work required on your side.

This weaving of developer-specific aspects is done through the notion of ClickStack plugins: a stack is the composition of multiple plugins, either provided by CloudBees, SaaS vendors, communities or enterprises, and composing the overall stack being deployed with your application. As an example, a SaaS vendor providing a JVM management solution and requiring an agent to be loaded when the JVM starts, wouldn’t have to maintain its own set of images. It would only have to create a trivially small ClickStack plugin that developers could add to the standard definition of their standard stack. Neither the customer nor the SaaS vendor become responsible for supporting that new stack as it will be maintained by the PaaS vendor and evolve over time.

Does ClickStack require a for-pay account?

No. Free accounts allow developers to run up to 5 free applications. Those applications can either use a CloudBees curated stack or a custom ClickStack.

Can I create my own ClickStack?

Yes. Much like for ClickStarts, the easiest way to create your own ClickStacks is to fork one of CloudBees curated stacks on GitHub (all of our ClickStacks are available under an open source license on Github) and to read the ClickStack documentation (+LINK TODO).

Can I make my ClickStack available to 3rd parties?

Yes, a ClickStack is only identified by a URL that can be consumed by anybody.

You’ll soon be able to register your ClickStack on CloudBees.com so that any user can browse and find your plugin, without having to visit your web site.

Can I make a ClickStack “private”?

TBD

How is a ClickStack different from Puppet or Chef?

Readers accustomed to Puppet and Chef will probably find similarities in the ability to build stacks from a set of recipes vs. using a set of plugins to compose a ClickStack.

Puppet and Chef will typically focus on lower-level constructs (storage, firewalls, etc.) that ClickStack will abstract for you. Furthermore, those frameworks provide ways to dynamically update the content of a stack – which is typical for stacks that are bound to run a long time without interruption. On a PaaS however, clients typically do not directly interact with a server stack (but go through a set of load-balancers) and stacks are created and killed frequently, which leads to a simpler stack lifecycle management.

However, even though a ClickStack tends to focus on higher-level concerns, it should be noted that a ClickStack plugin could be implemented as a Chef or Puppet recipe.

How is a ClickStack different than ProcFile

Much like described above (“I want flexibility in what I run, shouldn’t I be using a IaaS provider directly?”), those techniques only provide a way to build your own custom stack, but not to weave specific aspects within an existing and vendor-supported stack. Those solutions offer an “all-or-nothing” approach to customization, while ClickStack enables allows you to change only certain aspects of a stack. This proves to be much more efficient and helps developers remain focused on what they are supposed to do: create business value, not support and maintain stacks.

Can I run PHP/Ruby/Node.js/you-name-it on CloudBees?

Yes. As long as you can create a plugin for it, it will run on CloudBees. Since the ClickStack solution is based on Linux, stacks such as PHP, Ruby or node.js will work on CloudBees. Nevertheless, middleware layers that do not work on Linux (such as Microsoft .net) won’t run on the current ClickStack implementation.

Does this mean CloudBees is now a “polyglot” PaaS provider?

Technically, CloudBees is able to run multiple stack implementations, different runtimes, and as such would satisfy the most common definition of a what a “polyglot” PaaS provider is.

However, at CloudBees we think that a PaaS is more than just language support. Every language is surrounded by frameworks, libraries, as well as development and deployment processes that often depend on the nature of the language. The developers and their practices overlap, but we believe that significant depth is required to properly address the richness of each area.. As a customer, you are also expecting quality help and support from that vendor when something goes wrong. CloudBees has an outstanding team that has been building and supporting Java middleware for more than a decade, including JBoss, Weblogic, WebSphere, Glassfish, etc. As such, you’ll get access to top-Java talent. We currently do not have that level of expertise outside of the JVM and consequently do not support those environments. However, you are totally free to use CloudBees to run non-JVM based stacks and we will do our best to assist you.

If I create my own or use a 3rd party ClickStack, what is the scope of CloudBees support?

In short, CloudBees will be responsible for its own plugins