Apprenda has always provided a dedicated operations experience via our System Operation Center (SOC) portal. The SOC lets IT administrators centrally manage infrastructure and policies associated with an Apprenda deployment (whereas the Apprenda Developer Portal enables developers to define, deploy and manage applications with complete isolation from the infrastructure details).  In addition to the SOC, Apprenda customers can now manage their PaaS using a centralized System Center console and can automatically leverage its deep integration with Apprenda infrastructure pre-requisites like SQL Server and IIS. This translates into rich diagraming/UX dashboards/reporting, sophisticated rule processing capability, root cause analysis, automatic remediation, synthetic transactions and rich application insight (i.e. not just a set of flashing lights telling you when services are up or down).

Having spent nearly a decade working on systems management at Microsoft, I can tell you with complete confidence that management is often an oversight or a complete afterthought when introducing new tools and platforms into the datacenter – a ‘checkbox’ if you will. Well-meaning vendors build management capabilities into each of their products or simply provide management ‘frameworks’ expecting customer to roll their own solution. This in turn creates islands of disparate systems scattered throughout the organization resulting in higher costs and lower returns on the initial investment. If your management tool needs a management tool to be deployed and maintained, that’s usually a bad sign.

PaaS threatens to exacerbate this problem because many PaaS platform have not been designed for end user operation from the ground up. Instead they are designed to be operated directly by the vendor or a well-resourced service provider in a ‘pristine’ and tightly controlled environment. Enterprise customers do not have this luxury and need their PaaS to snap into place alongside their existing investments and adapt to the ever changing IT landscape.

One of our key goals at Appenda is to lower the barrier to adopting our PaaS by providing a truly turnkey deployment experience and eliminating the often overlooked management tax (which IT/Ops is typically left holding the bag for). By partnering closely with Microsoft, our customers can now seamlessly integrate Apprenda alongside the millions of other Windows Servers, applications and platforms already under the care of System Center and its thousands of trained professionals. Look for more exciting developments as we deepen this strategic alliance.

As a developer my ADVICE would consist of:

ACCESSIBLE - The platform must be easy to use and low friction to new development. The main thing here is that I don’t want the platform to get in the way of my daily development processes. For me the ability to easily port existing apps to the platform is secondary to the platform accelerating new projects.

DEPENDABLE - The platform must be resilient to failures, secure, and able to stand up to heavy loads. I need to know that the platform is going the handle the scale that I need.

VALUE - The platform should be more than a bit pusher. There should be APIs that will allow me to leverage the platform’s capabilities in order to save me time so I can get to the code that matters.

INTEGRATION - The platform needs to integrate well with the tools I use in my development. IDE, Continuous Integration tools, testing frameworks, etc. I want nightly builds of my application code automatically deployed to the platform and have our test suites run against the deployed app.

CONTROL – I should be able to deploy and manage my applications myself. If I have a new application to develop I want to be able to deploy, test, and publish that application without having to wait for procurement of infrastructure to get started.

EXTENSIBILITY - I would like the platform to be extensible so that I can customize it to fit our business needs.

See what I did there?

What do you think?

If you’d like to mingle with others in the Cloud space, the Apprenda group on LinkedIn now has 4200+ members and is growing every day; make sure you’ re not missing out and join today!

Dan and I will then be cracking open Visual Studio to take you through developing and deploying applications to run on a PaaS. We’ll also dive into managing, scaling, and patching those applications. We’re committed to making this webinar series as educational as possible, so don’t anticipate heavy product pitches. We want our viewers to come out of this webinar ready and able to tackle a PaaS deployment in their own enterprise, and perhaps be prepared to champion this technology within their organization.

The webinar is taking place at 12:00PM EDT tomorrow, 3/20, and should last for about an hour. If you can spare the time and are ready to learn, please join us by registering here!

To see more of our upcoming webinars, including the PaaS or Fail series, check out our webinars page.

In 2003 Microsoft acquired a company called Connectix, a provider of virtualization technology. At the time, Microsoft made the purchase for a use case that we called “legacy application re-hosting” – i.e. running NT 4 servers on shiny new hardware. Applications tended to outlast their hardware and we had scores of enterprise customers who needed to run older applications on modern hardware. Virtualization was the perfect technology to solve this very real customer problem. (You can read the press release here).

As Moore’s law outpaced the appetite for applications to consume hardware resources, server consolidation became the next major target for customer cost savings. The story was easy to tell and the savings were directly visible in your yearly budget because you simply purchased fewer servers. There were no fancy ROI charts or graphs needed.

Now, if you bought into virtualization to run NT 4 apps or to simply consolidate servers, you either missed or were blindsided by the massive datacenter transformation that ensued. When my team was first asked to build management tools for virtualized environments, many smart folks thought that we simply needed to add features and extend existing tools. Marketing was eager to tell the “manage virtual like physical with one set of tools” message (and Microsoft was not alone, nearly every systems management vendor took this approach). My team argued that this was backwards. Customers should manage physical like virtual because that’s where the real benefits would be uncovered. The gains in overall IT agility and operational efficiency would not be as easy to quantify as the simple server consolidation story but they were at least an order of magnitude more powerful. I recall being in a meeting where one of our engineers was frustrated with internal IT’s inability to justify the cost savings and said “I have an idea to save you all lots of money. Turn off all the servers!”

I take this walk down memory lane because I can’t help but noticed the parallels to what is happening in the PaaS space. Like server consolidation before it, rapid “push” of applications without IT involvement is an easily quantifiable and very real benefit (plus it makes a great demo). While important, this will ultimately be a footnote in the PaaS revolution which promises to change not only how developers deploy apps but also how they write, manage and run them. In the case of Apprenda’s private PaaS, it also means providing IT professionals with easy to use and powerful tools to operate the PaaS like a world class service provider.

These downstream benefits may be harder to quantify and attach a dollar value to but they should be the basis upon which PaaS vendors are measured. The early and short term benefits of PaaS are still important because they create a bridge to more meaningful value. With that said, once you make the easy money on your PaaS implementation, remember that you’ve only just hit the tip of the iceberg.

As always, please share your thoughts and questions. If you have other topics you’d like to see covered let us know in the comments or on twitter.

Please share your thoughts and questions. If you have other topics you’d like to see covered let us know in the comments or on twitter.

Understanding Where PaaS Runtimes Fit in

What makes a runtime architecture for PaaS interesting is that PaaS runtimes instrument themselves into their guest application’s execution model, introducing new, enhanced behavior to those guest applications. This instrumentation can happen at the highest level of granularity such as at the HTTP conversation level, and, as is the case in Apprenda, can go down to threading behavior in the .NET CLR and even how CPU is managed across cores. Clearly, a runtime is much heavier R&D lift, hence the focus on single languages with depth rather than shallow value across many languages, but boy, when the customer asks “show me the money”, what a difference. In this post, I decided to take everyone through a deep dive of what a PaaS runtime can do that you can’t do with the non-runtime PaaS flavors. I’ll actually walk you through an application deployment on Apprenda and how to quantify the value. Although nuanced, the goal isn’t to dig on other PaaS offerings, but instead, to show what PaaS runtimes can do and how to quantify their value. At the same time, it’s important to realize that no other PaaS can replicate the sort of value I’m going to discuss.

To set the stage, let’s settle on a very basic framework for what a PaaS runtime should do:

1. Abstract underlying infrastructure resources into a shared pool, decoupling the application and developer from those infrastructure details
2. Providing a backdrop for all application management tasks, ranging from application deployment to application updating
3. Provide APIs and a runtime execution engine that helps developers trivially build one of the four cloud application archetypes.

In this post, I plan to show all 3 framework components in action, with emphasis on bullet 3. In subsequent posts I will zoom in on bullets 1 and 2 to show a greater level of detail.

An Experiment to Evidence the Value of PaaS Runtimes

My co-founder and VP of Client Services, Matt Ammerman, ran a little experiment with our Apprenda PaaS – he took an already built multi-tenant .NET application, and moved it to Apprenda to see how much easier (if at all) it would have been to build on Apprenda. The purpose of this is that we strongly believe that a PaaS runtime must equip developers to be able to write cloud application architectures with little to no heavy lifting, much like the JVM or CLR equip developers to write managed memory applications with features like automated exception handling with no heavy lifting.

For his experiment, Matt decided to use a well-known sample application created by Microsoft known as “Fabrikam Shipping” as his target. You can check it out here (source code link at the bottom of the Fabrikam page or grab it from MS’ website here). Fabrikam Shipping is an application targeting Windows Azure that embodies a proper, multi-tenant web service architecture. It’s really great work and highlights certain key aspects of Azure (which is one of the more impressive PaaS offerings out there). The Fabrikam application architecture aims to provide a reusable architecture pattern for multi-tenant services and is composed of 20 Visual Studio projects that define:

1. The core application logic and presentation model
2. Multi-tenancy (Isolation models including fully isolated and fully shared)
3. Tenant provisioning services and UIs
4. Metering & billing
5. Identity management & federated identity services
6. Azure services management

We’re going to start at the results first. As a PaaS runtime, Apprenda already provides a bunch of these capabilities in an *inherited* way, meaning that by running the Core Application only on the Apprenda platform, Apprenda can instrument this sort of architecture into Fabrikam, achieving the intended outcome, and add even more functionality like scale-out, database sharding, query scoping, monitoring, entitlements management, etc. . Essentially, Matt removed all code from Fabrikam that wasn’t part of bullet 1 above. This means he removed all auxiliary services in 2-6, as well as any code in 1 that was in support of 2-6 (such as code in 1 related to multi-tenancy). Matt ran Visual Studio’s built-in code metrics tool before he ported Fabrikam to Apprenda, and after. Here are the results:

Doing the math, that’s an 84% reduction in the total lines of code, without sacrificing quality or functionality. Yes, “lines of code” are not a good measure of productivity in the general case, but when you back 84% of the code out of a project and have more capability, there is something meaningful communicated in the metric. As a weighted function, that 84% represents tricky topics like multi-tenancy and identity federation, so it’s a much more difficult 84% than the remaining 16%.  In this case, this isn’t a knock against Azure – Azure is amazingly powerful tech in many different ways, but it does quantify Apprenda’s value quite clearly. If you run this trimmed down version of Fabrikam on any other PaaS, you just end up with the basic behavior represented in the code – no additional capabilities. This means that in other PaaS’, you’re still responsible for lots of the cloud architecture heavy lifting. Don’t believe me? Give it a try (link to source is below – just comment out the two lines of Apprenda specific code in the project) To understand how we threw out 84% of the code, let’s dig in to the Fabrikam Visual Studio solution. Here is a screenshot of the Visual Studio Solution structure with some highlighting (I explain the highlighting below):

(bigger)

On the right-side of the screenshot, you’ll notice that I’ve tagged the project with what part of the architecture the given project represents. Projects highlighted in red represented functionality unneeded on Apprenda, so they were deleted. The two remaining core projects representing the Core Application could be deployed to Apprenda as-is. However, the 2 projects were modified by adding 2 lines of  code which were not necessary for the app to run but needed to personalize the UI the way the original Fabrikam did. The reason we could do this is that the expectation for a cloud architecture outcome is shifted away from the developers who built Fabrikam, and to the underlying Apprenda PaaS runtime.

(bigger)

As a runtime, Apprenda instruments itself at cutpoints inbetween tiers, managing call flow and context, and also hosts application components themselves either in traditional Microsoft containers like IIS but enhanced with in-memory components that help the application execute, or by hosting them in custom Apprenda based containers, such as our P2P service container system. This instrumentation allows Apprenda to create a functional outcome that is different than was intended by the developers of the original application, but can take configuration items from those developers to help dictate what the ultimate outcome is (like being able to instruct Apprenda on isolation patterns, etc.). The end result is an app that does much more than what the code of the app would lead you to believe.

Deploying the Application

Once Matt completed these changes, the next step was to package the new Fabrikam and deploy it to an Apprenda instance. Matt used our CLI, the Apprenda Cloud Shell (acs for short – please note, we haven’t released the acs yet, but will be making it available shortly), to do this. Matt could have used our Developer Portal, a web-based portal for app management, but chose not to. Essentially, Matt used two key acs commands:

1. ConnectCloud to connect to an Apprenda instance that he already registered on his local dev environment (you can register Apprenda URLs and alias them for easy reference later. For example, you may register things like “My Laptop”, “Dev”, “Staging”, and “Production” clouds and then refer to them as such later.
2. NewApplication to create a new application against the connected cloud. This command allows Matt to provide a path to his solution. Once the command is submitted to acs, a build is kicked off, the binaries are packaged on the fly, and are then pushed to the Apprenda cloud. There are a bunch of flags that can be supplied, like Stage, which tells Apprenda that this is either a “Sandbox” deployment or a “Published” deployment (Apprenda has rigid stage constructs to help govern versioning and version lifecycles)
3. You’ll see Matt use other command like GetStatistics and DisconnectCloud. Don’t worry about these for now.

Watch the video to see all of this in action (it zooms in after a few seconds so you can see some of the detail).

The only thing not really shown here is that Matt had created a deployment-manifest.xml file that is bundled in the application archive that is packaged and pushed to the Apprenda cloud instance. This file contains configuration information consumed by Apprenda during the deployment of the application, including information like what application services to bind to, what isolation strategies to use at different tiers (like the presentation or persistence tiers of your application), etc. The image shows you a snapshot of a manifest.

(bigger)

If you think about what we’ve done, we’ve taken an application that, if written on Apprenda to begin with, would have contained 84% less code, be written as a standard web app, but would run as a full blown cloud application with all the bells and whistles. Additionally, we deployed the application in a single command. The only way to acheive this is via a PaaS runtime, and not via the typical PaaS architectures you see out in the wild. Doing runtime and expert depth in .NET is what makes this value possible.This is what you get with laser focus on being best of breed.

The amazing R&D staff at Apprenda made this happen because they built a model for PaaS that focuses on a runtime, application container model rather than simply focusing on application management tasks. This sort of stuff is what makes Apprenda insanely great. We’re quite certain (clearly, we can’t be 100% positive), that no other PaaS on earth can achieve this sort of outcome - an outcome that produces huge value for developers. And to think, we haven’t even touched things like caching, publish/subscribe events, etc.! Even more interesting is that this is just one app – our customers have hundreds and will build hundreds more in the future so the benefits get multiplied. With that said, using Apprenda for even just one mission critical application produces real tangible ROI immediately (just count the weeks of coding that you saved multiplied by the cost of highly specialized devs who can write this code for Fabrikam and then add the maintenance cost).

Over the coming weeks, I plan to refer back to this Fabrikam example and walk you through what it’s like to manage an application running on Apprenda, and also what it’s like to be the platform owner that operates an Apprenda instance on the behalf of all the development teams that use it. In the meantime, click one of the links below and download Apprenda Express and install a PaaS cloud on your laptop, download the original Fabrikam source code, download the modified one described in the post, or download an Apprenda Archive file with a packaged version of the ‘Apprenda-ready’ Fabrikam source code. Here are some links to those resources. (Be sure you have minimum requirements taken care of -Apprenda Express for the Apprenda version of Fabrikam if you want to compile, the Azure SDK for Fabrikam on Azure)

I hope you walk away feeling the way I do – that anything less than a PaaS runtime is unacceptable and focus on bringing the best value to each stack in a depth first way is the only way to go. You should expect your PaaS to help you write, deploy and manage cloud applications faster and better. Don’t be tricked into thinking that PaaS is all about AppOps/DevOps/whateverOps – while there is tons of value in that, it is only a drop in the bucket in the context of a model that helps developers build world-class apps with modern architectures.

Feel free to leave any comments you might have. Also, do you have any suggestions with respect to what you’d like to see in the follow up posts? If so, let me know as well!

Please share your thoughts and questions. If you have other topics you’d like to see covered let us know in the comments or on twitter.

Here’s a breakdown of the highlights, along with a link to the original post on Stephen’s blog:

Apprenda Is an OS Layer for the Datacenter — Sinclair Schuller

00:00 — Introductions from Sinclair and Dan from Apprenda
01:00 — Tell us about Apprenda and its history
04:36 — Approach of the cloud from internal developer perspective
06:24 — Solution is for private cloud; can it support hybrid, public clouds, and SaaS?
09:11 — How does Apprenda play with Microsoft and Azure?

An Interview With Apprenda: Watch Out for the PaaS Revolution