3. Why Deliver Applications as SaaS
Enterprises Consumption of SaaS Applications is Exploding
• Will reach $14.5 Billion in 2012
Reduces Sales Cycle
• Customers can buy online rather than going through 60 to 90 day sales cycles
Accelerates Adoption
• Customers uptake SaaS apps faster than software that needs to be deployed
Simplifies support matrix
• SaaS vendors don’t have to support the legacy middleware
3
4. Characteristics of a SaaS Application
Global users
Web app
Dynamically flexible
Available Anywhere infrastructure Web Based with
over internet no client installation
Low cost, high SLA
requirements
Customizable
Scalable & Elastic
with no performance
degradation
Metered and charged for Shared by 2 or more
actual usage customers
4
5. Implications for ISVs
SaaS vendors are not just ISVs but also Service Providers
• You will need to deal with infrastructure, performance and availability of the app
Serve Global Customers Really Fast
• Your users will demand high performance irrespective of their physical location
Reduce Upfront Cost per User
• Your customers will pay for what they use and so should you
Build and Update Applications Faster – Consistently
• Use productive development frameworks and methodologies
• Minimize time spent on infrastructure
Run on a Flexible, Scalable and Elastic Platform
• As more customers buy your app, you need app platform that can scale up and down
quickly and effortlessly
Manage and Monitor in Real Time to Deliver on SLAs
• Find and fix application and infrastructure problems BEFORE they happen
5
6. The Challenge of Scale
The web and application tiers can
be easily combined and Load Balancer
virtualized. Nodes can be added or Add/remove
removed on the fly. web/application servers
Web Tier
Application Tier
The database only grows by Database Tier
moving the VM to a larger
machine
The disk systems can be
virtualized and can grow on Storage Tier
demand
6
8. VMware vFabric Cloud Application Platform
Build
Frameworks & Tools Rich Social and Data Integration Batch Spring
Web Mobile Access Patterns Framework Tool Suite
vFabric
Java Runtime Web Runtime Messaging High Speed Data Performance Mgmt
Application Services
Data App
EM4J
Director Director APM
Run vSphere 5
Manage
8
10. vFabric: A Modern Approach to Application Infrastructure
Lightweight, simplicity
• Commercial Tomcat as core container
• Optimized for vSphere and Spring
Licensed for SaaS Applications
• Per VM pricing
• Per CPU pricing
Modernize Today’s Applications,
Build for Tomorrow’s
10
11. vFabric tc Server
The Best Place to Build and Run
Spring Applications
11 vmware.com/go/tc
12. tc Server: Replace Legacy Java Servers and Apache Tomcat
Efficient, lean, fit-to-purpose runtime platform
Lower cost and complexity
Enterprise capabilities on Apache Tomcat-compatible base
12 vmware.com/go/tc
13. Sample Benefits of Lightweight Java Approach
Task Heavy JEE Lightweight Java
Server Simplest possible application
500 MB 50 MB
Consolid- (“Hello World”)
ation
App Server Installation footprint 700 MB / 1.7 GB 15 MB
Server provisioning 1 hours / days seconds / minutes
Time-to- Application installs 1 hours / days seconds / minutes
market
Installation & configuration scripts
~ 60,000 LoC ~ 1500 LoC
overhead, per release
Elasticity Server startup time1 minutes / hours seconds
1 Assumes ops intervention due to server complexity, vs. self-service model.
2 Estimate based on reduced server complexity / test cases / customization.
13 vmware.com/vfabric
14. EM4J enables Java heap memory pooling
Elastic Memory for Java (EM4J)
Java Java Java Java Java Java
Heap Heap Heap Heap Heap Heap
Java App Java App Java App Java App Java App Java App
Guest OS Guest OS Guest OS Guest OS Guest OS Guest OS
vSphere Host
14 vmware.com/go/tc
15. vFabric tc Server
Spring Insight Operations
Rapid Resolution of Application Performance Problems
15 vmware.com/go/tc
20. Gemfire - Enabling Extreme Data Scalability & Elasticity
Primary Use Cases
Web Session Cache, L2 Cache
• Shopping Cart state management
App Data Cache, In-memory DB
• High performance OLTP
Application Data Grid Data Fabric: Client Compute
Lives Here • Shared data grid accessed by many
clients executing app logic
Grid Data Fabric: Fabric Compute
• Shared data grid where app logic is
executed within the data fabric itself
Application Data
Sleeps Here
File Systems Databases Mainframes / other
20
21. SQLFire
What it is
• Memory-oriented clustered database
• Pools memory and disk from hundreds of nodes
• ACID transactions
• Can cache existing RDBMS data
• Accessible by JDBC or ADO.NET clients
• SQL conformance based on Apache Derby and ANSI SQL-92 compliance
21
23. APM/Hyperic – Composite Monitoring (Net/Services/Code)
What is the source
of bottlenecks?
Is performance
within SLAs?
End user
Web Servers App Servers
Databases
How is
infrastructure How can I improve
impacting app performance?
response times?
23
24. Can you measure KPMs across your datacenter?
Application Frameworks
Application Servers
Web Servers / Caches
Messaging Middleware
Databases
Directory Services
Email
Operating Systems
Virtualization
24
26. Build Your App
Define relationship to
create a topology and
Select components Select scripts and
from a standardized set configurations
catalogue and parameters
26
27. Orchestrate Deployment
Automatically
generate a
deployment flow
Set callouts for
notifications and 3rd
party product
integrations
27
29. vFabric Data Director Powers Database-as-a-Service
vFabric Data Director
Automation Backup/ One click
Provisioning Clone
Self-Service Restore HA
DBA App Dev
Policy Based Resource Security Database
Monitor
Control Mgmt Mgmt Templates
DBA IT Admin
VMware vSphere
29
31. Web Era vs. Cloud Era Approach to Application Platform
Web Era (App Server) Cloud Era (PaaS)
Step 1: Download and install Step 1: Write your application using
components your language of choice
• App servers, Web servers, Load Balancers,
database etc. Step 2: Push that app to the PaaS
• Install and connect additional services provider
(messaging, for example) • Public
• Private
Step 2: Wire the components together
• Configure and Connect specified number of app
servers, web servers and databases
Step 3: Update components as required
• Apply patches to each component
• Manually increase/decrease capacity
Step 4: Write your application
Step 5: Deploy your application
Step 6: Repeat steps once through
Dev, Test, UAT, Prod
31
32. Choice of Application Services
.js
Data
Services Private
Clouds
Msg
Services Public
Partners
Clouds
.COM
Other
Services
Micro
Clouds
32
33. Q & A + Additional Resources
Learn More about VMware vFabric
Cloud Application Platform
Product info vmware.com/go/vfabric
60 day trial vmware.com/go/tryvfabric
vfabric@vmware.com
Product expert
855 TRY VFABRIC (879 8322)
33
34. Thank You
This webcast has been recorded and a link to the on-demand version
will be sent to you in a follow-up e-mail along with a PDF copy of the slides.
34
Editor's Notes
VMware’s Cloud Application Platform addresses the needs of BOTH developers and operations by combining market-leading developer frameworks and tools with integrated application platform services to deliver speed, portability, and optimized use of cloud resources.The Modern Frameworks and Tools enable developers to build innovative new applications in a familiar and productive way while enabling the choice of where to run those applications (inside the datacenter or on private, hybrid, or public clouds). The Modern Platform Services are much more agile and designed for virtualization. Unlike traditional middleware platforms, these platform services provide lightweight footprints that make the best use of the underlying virtual infrastructure platform as well as enable businesses to bring applications to market faster and with less complexity: new applications can be delivered in days or weeks rather than months or years, and at scale.Spring fwk allows you to make apps easy to work on.Decouple code from underlying app services===================================Need to modify the clocks..Need to know dollars saving for EM4JThe VMware Cloud Application Platform combines the Spring Framework for building new applications together with a complete set of Application Platform Services required to run and manage these applications.[CLICK] Spring Framework: Spring is a comprehensive family of developer frameworks and tools that enable developers build innovative new applications in a familiar and productive way while enabling the choice of where to run those applications, whether inside the datacenter or on private, hybrid, or public clouds. Spring enables developers to create applications that: Provide a rich, modern user experience across a range of platforms, browsers and personal devices Integrate applications using proven Enterprise Application Integration patterns, including batch processing Access data in a wide range of structured and unstructured formats Leverage popular social media services and cloud service API’s[CLICK] VMware vFabric: VMware vFabric is a comprehensive family of application services uniquely optimized for cloud computing including lightweight application server, global data management, cloud-ready messaging, dynamic load balancing and application performance management. [CLICK] The products behind these services include: Lightweight Application Server: tc Server, an enterprise version of Apache Tomcat, is optimized for Spring and VMware vSphere and can be instantaneously provisioned to meet the scalability needs of modern applications Data Management Services: GemFire speeds application performance and eliminates database bottlenecks by providing real-time access to globally distributed data Cloud-ready Messaging Service: RabbitMQ facilitates communications between applications inside and outside the datacenter Dynamic Load Balancer: ERS, an enterprise version Apache web server, ensures optimal performance by distributing and balancing application load Application Performance Management: Hyperic enables proactive performance management through transparent visibility into modern applications deployed across physical, virtual, and cloud environments Policy-Driven Automation: Project Napa is the code name for a new offering still under development that is focused on policy-based automation of application and platform configuration and provisioning tasks.
vFabric 5 is really focused on those 2 challenges:Application platform optimized for both the Spring Framework that is used by the majority of the world’s Java developersLicensed for the realities of the modern datacenterAnd as I’ll cover in a moment, containing the core components of our PaaS offering, thereby creating a pathway for our customers to the PaaS era.
What kind of benefits can be had from such a platform?This is an example from one of our large Financial Services customers with very large Java deployments. They are comparing their existing WebSphere-based infrastructure with our modern, lightweight alternative.Operational savings for such things as server provisioning and application installs can be driven down from hours/days to seconds/minutes.The complexity of application infrastructure can be dramatically reduced as well. With Gigabyte footprints reduced to Megabytes and corresponding installation and configuration scripts reduced by orders of magnitude.These are just some examples, from the customer’s perspective, of the measurable benefits.
EM4J lets a vFabric tc Server instance under memory pressure, due a high workload, borrow java heap memory from other tc Server instances running on the same vSphere host. Then release that memory as their workload subsides.Vsphere Hypervisor can borrow memory from one tcServer or Tomcat JVM and loan it to another Prevent swapping in busy systemsProvision large heap sizes while maintaining high utilization – Allocated memory will not go to wasteIncrease reliability under load stressEM4J provides dynamically and automatically adjusted at runtime as the Java heap memory requires of app servers grow and shrink with changing workloads.Only VMware can provide this, because only VMware has engineering expertise around both a mainstream hypervisor, and a mainstream application server. That hypervisor is, of course, vSphere. The application sever is tc Server, based on open source Apache Tomcat, the world’s most popular Java application server, used for running production applications in over 60% of large businesses and organizations worldwide.
Inside JVM visibilityVsphere Hypervisor can borrow memory from one tcServer or Tomcat JVM and loan it to another Prevent swapping in busy systemsProvision large heap sizes while maintaining high utilization – Allocated memory will not go to wasteIncrease reliability under load stress
AMQP – new wire level protocol like HTTP. What it means – low level protocol so language independent – C++, Java, Mainframe, Windows – all can make calls and hence integrate systems that couldn’t be integrated earlier.Old ESB style messaging doesn’t work for SaaS apps because everything has to be integrated to single ESB Challenging to scale.Hub and spoke patterns and many of hub and spoke patterns instead of one big monolithic bus. Lighweight, distributed – AMQP implementation.
Use Case 3:There are typically many clients: one of the scenarios we often see is where the clients are desktops, executing macros and pulling real time data from the data grid. This is in fact a significant mostly what the financial services customers are doing on Wall Street: pretty much every bank is using GemFire today (primarily for their trading apps)The clients are pulling data from the grid and executing some kind of logic on the data – similar to a typical messaging use case with a message broker, except much faster because the data is always local to the app that needs it. In this way you get huge improvements in throughputCustomer is creating a true data grid: lots of clients, connecting to many nodes, some of which may cross WAN’sThe data is kept in sync across all nodes at all times and so is highly available. Data can be persisted using lazy writes in order to achieve database-like reliabilityThe data grid can be used to publish and subscribe messages across topologies – and so for many use cases acts as the message broker as well as the data store – eliminating the need for a messaging layer altogetherUse Case 4:The primary difference when compared to #4 is that the execution is actually being done IN THE DATA LAYER. Both GemFire and Coherence have the ability to execute code within the process – and so allowing for an even greater throughput when compared to scenario #3. In this case it somewhat blurs the line between the typical 3 tier architecture…and so is a pretty high-end use case. However that being said, it is in fact what high end fin services customers are doing with the product.Faster ThruputPower of GF toUnify data – no sql data, new sql data, sql data – in a data grid to create a unified data set. Execute logic within data grid. Set up messaging and watch data change in real time. Key CapabilitiesLow-Latency, Linearly-Scalable, Memory-based Data FabricData distribution, replication, partitioning and co-locationPools memory and disk across many nodes Data-aware ExecutionMove functionality to the data for peak performanceActive/Continuous Querying and Event NotificationChanges are propagated to one or more "active" copiesUse Cases 3 and 4 are where GemFire excels, and is where we start to get well beyond simple caching technologies. There are really only a couple of products that address this in an enterprise manner: GemFire and Oracle Coherence. Use Case 3: The end result is really about faster throughput. I would guess that this would be of interest to Reuters given what they do. I believe that they use Tibco for messaging (at one time they were an investor in Tibco if I recall correctly) and so they may have strong architectural opinions about how to achieve scale for messaging, but at the data layer they would need something like GemFire.
We’ve talked about the problems of traditional databases along with the pros and cons of NoSQL solutions. So what? Do we have to pick whichever bad or wrong solution we can live with the best? Or is there something we can use today to give us the scalability of NoSQL without compromising on the ACID characteristics of our existing database? Is there something we can use that won’t force us to rewrite our data access layer? Is there something that will do all that and work with our existing database? <CLICK>The answer is yes and the solution is SQLFire.<CLICK>SQLFire is an in-memory clustered SQL database. It pools memory and disks from as many nodes as your infrastructure (both virtual and physical) will allow. SQLFire builds on the technology of the GemFire distributed cache system. Although GemFire provides much of the underlying technology for a SQLFire data fabric, the two are not interchangeable.SQLFire does not compromise on the atomicity, consistency, isolation, or durability of its transactions. It doesn’t ‘punt’ on this by claiming these transaction characteristics aren’t necessary.The data in SQLFire can be data cached from your existing data stores.Access by applications is presently permitted in either .NET or Java applications. .NET through the ADO.NET client, Java through the JDBC driver. Both of these are provided in the SQLFire distribution.SQLFire conforms to up-to-date SQL standards which, by themselves, can be somewhat incomplete leading vendors to implement some portions of their SQL implementations in a vendor-specific way. SQLFire tries to adhere to the Apache Derby dialect in this sense as it is a well-known, well-documented SQL dialect which also serves as the foundation for the database shipped with Java itself: Java DB.
You can build your own plug in and we are adding new ones at every opportunity (75+ already) =====================================The cold reality is that a typical datacenter will have a wide range of technologies, making effective app management extremely difficult.Can you manage everything in your datacenter? Will you be able to manage technologies that will be acquired in the next 12 months? Are you sure your monitoring is future-proof?Hyperic can monitor all this and more. Plus its community is constantly building support for new servers, based on Hyperic’s easily extensible plug-in development kit.More information:http://www.hyperic.com/products/supported-technologiesTo view the metrics that Hyperic supports:Log into HypericAdministration tabClick “Monitoring Defaults”Select the technology of interestClick “Edit Metric Template”
Self Service app provisioning
With App Director, when you create blueprint, you know you got it right because that’s how the app will be built! App visualization tools may or may not be true but App Director is always right.
This graphic illustrates the mechanics:DBA sets the policies associated with the databasesApplication development teams then access a self-service portal
The third element of openness is in the realm of deployment choices.The ability to run Cloud Foundry on a range of infrastructures is a fundamental philosophy. CF is supported in the following formats:Micro cloud foundry: a downloadable developer instance that can run on a developer’s laptop. Limited to a single VM, this provides developers with the ability do run a PaaS on their laptop: they can build and run applications locally without ever having to install middleware! They can build the app locally and then deploy it to their choice of clouds where it can scale up to 100s of instances. Public clouds: www.cloudfoundry.com is VMware’s offering, but there are many other partners running the service as well so that you are not limited.Private clouds: we know that customers want to have that PaaS experience inside the firewall, and therefore in FY12 will be providing a private instance of Cloud Foundry that organizations can stand up as a PaaS of their own.This choice of deployment clouds is one of the elements that really stands VMware apart.