3. 3
VMware’s Three Strategic Focus Areas
Evolve the Core Infrastructure
Modernize Application Development
Re-think End-User Computing
Private
Clouds
Public
CloudsEnable Hybrid
5. 5
What trends are driving the application platform market?
New Frameworks & Languages
• Increase developer productivity
• Reduce time to market
New Devices and Domains
• Mobile, social, and SaaS integration
New Data Types and Requirements
• Data deluge driving data tier elasticity
• Flexible NoSQL data solutions
• Realtime data
New Infrastructures
• Virtualization & Cloud
6. 6
Core Components of Application Infrastructure
Clients
Web Servers
App Servers
Databases
Monitoring
App Framework
Message Servers
8. 8
The vFabric Approach to Application Infrastructure
Clients
vFabric
Web Server
vFabric
SQLFire
vFabric
RabbitMQ
vFabric
tc Server
GemFire App Cache Node
Elastic Memory for Java
Spring Insight Operations
vFabric Hyperic
10. 10
What are we announcing…and when?
vFabric 5: Application Infrastructure for the Cloud Generation
• LICENSED for virtual and cloud
• PACKAGED for simplicity and reuse
• ENGINEERED for vSphere and Spring
SQLFire beta
Announcement: Tuesday June 14th. GA: Tuesday August 16th
11. 11
vFabric 5: Licensed for Virtual and Cloud
vFabric Standard
$1,200 per VM (perpetual)
+ 21% / 25% SnS
Hyperic
Server-Level Monitoring
tc Server Spring Edition
Tomcat Java Application Server
+ Spring Insight Operations
Web Server
Apache HTTP Server
GemFire App Cache Node
Session and Hibernate Caching
Standard
SQLFire Professional Edition
Memory-oriented data management
vFabric Advanced
$1,800 per VM (perpetual)
+ 21% / 25% SnS
Per VM pricing: an industry first for application infrastructure
Up to 2 vCPUs per VM. More than 2 vCPUs in a VM? Divide by 2 then round up.
RabbitMQ
Message Broker
Elastic Memory for Java (EM4J)
Elastic Memory Management
Metric =
New
12. 12
vFabric 5: Optimized for Spring and vSphere
Optimized for vSphere
• tc Server
• Elastic Memory 4 Java (EM4J)
• Pools memory across tc Server instances
• Allows increased Server Consolidation ratios for tc Server on vSphere
• Reduces out of memory errors that can cripple your applications
Optimized for Spring
• tc Server
• Spring Insight Operations
• Spring Insight technology, now engineered for production use cases
• Tomcat 7
• Parallel Deployment for zero-downtime application upgrades
• Hyperic
• Includes Spring Insight Operations metrics
13. 13
vFabric Forecasted Timeline (subject to change)
June July August September October
vFabric
Announcement
June 14 2011
Channel pricelist
published vFabric GA
August 16 2011
(all but SQLFire)
SQLFire
GA
16. 16
Enabling Extreme Data Scalability & Elasticity
Application Data
Lives Here
File Systems Databases Mainframes / other
Application Data
Sleeps Here
Primary Use Cases
Web Session Cache, L2 Cache
• Shopping Cart state management
App Data Cache, In-memory DB
• High performance OLTP
Grid Data Fabric: Client Compute
• 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
17. 17
GemFire
1. Peer-to-Peer
the cache is embedded within the application process and shares
the heap space with the application
Session replication and L2 cache
Primary GemFire Topologies Use Cases
OS
Java APP
JVM
A/S
OS
Java APP
JVM
A/S
18. 18
GemFire
JVM
2. Client/Server
A central cache is managed in one distributed system tier by a number of servers
Session replication and L2 cache, data intensive apps, DR, continuous availability…
Primary GemFire Topologies Use Cases
OS
Java APP
JVM
A/S C/S topology
supports native
clients (C#, C++)
OS
Java APP
JVM
A/S
Win
C# APP
CLR
.NET
OS OS
JVM
19. 19
3. Multi-site caching
Distribution of cached data between sites is seamless to the applications within each
distributed system. If any system becomes unavailable, the rest of the installation
continues to operate.
Primary GemFire Topologies Use Cases
WANGemFireJVM
OS
Java APP
JVM
A/S
OS
Java APP
JVM
A/S
Win
C# APP
CLR
.NET
OS OS
JVM GemFireJVM
OS
Java APP
JVM
A/S
OS
Java APP
JVM
A/S
Win
C# APP
CLR
.NET
OS OS
JVM
23. 23
Replicated Caching Example
Replicated caching gives you a complete copy of your data in each
JVM in the distributed system that hosts the replicated region.
2 Confidential
27. 27
Standard SQL
• Easily incorporate a
memory-oriented approach
to data management for
applications
• Leverage existing tools to
accelerate app
development
High Performance
• Eliminate disk I/O
performance constraints:
data at the speed of
memory
• Enables distributed data
access: move data closer to
apps to reduce latency
Horizontal Scale
• Near-linear scale to
accommodate application
demand
• Supports global WAN
connectivity
Leverage broad SQL
knowledge – reduce time
to market
Accommodate shifting
user load
Data at cloud scale
Key SQLFire Positioning
New
28. 28
vFabric SQLFire beta community site
http://communities.vmware.com/community/vmtn/appplatform/vfabric_sqlfire
30. 30
Spring and tc Server (Enterprise Tomcat)
Efficient, lean, fit-to-purpose runtime platform
Lower cost and complexity
Enterprise capabilities on Tomcat-compatible base
Best platform to run Spring applications
31. 31
Enough is Enough
Too many clients spend far too much time and effort trying to find the
products with the most features. Lean shops look for just enough, no more.“ ”
32. 32
vFabric tc Server: Key Highlights
Developer
Efficiency
Familiar Spring + Tomcat experience
Deep performance insight into Spring apps
Agile Spring development experience via STS
Enhanced build process via Maven plugin
Operational
Control
Performance & SLA management of Spring apps
Application provisioning and server administration
Rich alert definition, workflows, and control actions
Group availability & event dashboards
Secure unidirectional agent communications
Deployment
Flexibility
Lean server (10 MB) ideal for virtual environments
Template-driven server instance creation
Integrated experience with VMware environments
Open, secure API for all operations
33. 33
Deep Performance Insight into Spring Apps
Spring Insight Operations
Description Benefits
• Helps pinpoint performance problems coming from
problems in code
• Tracing available in production minimizes need to
reproduce problems in the lab
• Common view between developers and operations
simplifies escalations
• Transparently
instrument Spring
applications at the
code level
• Roll up data from
multiple application
nodes with filters and
drill down
• Hyperic integration for
unified operational
view and robust
alerting
34. 34
How is each part of my
app performing over time?
Are the response times
within expected SLAs?
Are problems occurring for
all users, or just some?
Is the database a
bottleneck?
Is one of my
servers running
apps slowly?
Which parts of
my app are
slow?
Is client
performance a
problem?
What parts of my code are
responsible for slow
performance?
Which app are slow?
35. 35
Use ESX to Share Memory Between VMs Running Java
Elastic Memory for Java (EM4J)
Description Benefits
• Higher consolidation through memory over-commit for
Java workloads
• Protect Java applications against workload spikes
without wasting memory
• Lets you give Java more memory than it needs under
normal load. Memory your application doesn’t need is
returned to ESX but remains available in case it is
needed to avoid Java out-of-memory errors
• Use virtualization to
overcome the
limitation of Java’s
static heap
• New ‘memory balloon’
runs inside JVM to
capture unused
memory and return it
to ESX
• Memory returned to
JVM when it is under
pressure
36. 36
Ensure Java Runs Well on vSphere
Java Best Practice Analyzer
Description Benefits
• Eliminates misconfiguration, the #1 cause of slow Java
performance on vSphere
• Enables vSphere admin to see in one place whether
the vSphere-level and Java-level configurations follow
best practices
• Tells you what the problems are and how to solve them
• Helps admins make best use of EM4J
• vSphere client plug-in
to check and control
settings on the VM,
inside the OS, and on
the JVM.
• Identifies common
configuration and
deployment problems.
• Monitors and controls
EM4J
37. 37
Sample Benefits of Lightweight Java Approach
Task Heavy J2EE Lightweight Java
Simplest possible application
(“Hello World”)
500 MB 50 MB
App Server Installation footprint 700 MB / 1.7 GB 15 MB
1 Assumes ops intervention due to server complexity, vs. self-service model.
2 Estimate based on reduced server complexity / test cases / customization.
Time-to-
market
Elasticity
Server
Consolid-
ation
Server startup time1 minutes / hours seconds
Server provisioning 1 hours / days seconds / minutes
Application installs 1 hours / days seconds / minutes
Installation & configuration scripts
overhead, per release
~ 60,000 LoC ~ 1500 LoC
39. 39
Estimate 300-500 in production, 15-20,000 in dev
Customers love RabbitMQ – banking, web, social media, ...
40. 40
Modern Messaging for the Cloud
Cloud-scale Message Bus
RabbitMQ Message Broker
AMQP, HTTP, HTTPS, STOMP, SMTP, XMPP …
Point -to-point and pub-sub
Virtual hosts, dynamic configuration
Cloud Services DevicesApplications
41. 41
RabbitMQ and AMQP: A simple view
Consumers create queues; these buffer
messages for push to consumers
Queues are stateful, ordered, and can be
persistent, transient, private, shared.
Exchanges are stateless routing tables.
Consumers tell queues to bind to named
exchanges; each binding has a pattern e.g.
“tony” or “*.ibm.*”
Producers send messages to exchanges
with a routing key e.g. “tony”, or ordered set
of keys e.g. “buy.ibm.nyse”
Exchanges route messages to queues
whose binding pattern matches the
message routing key or keys
42. 42
C# C Hundreds of
other clients
RabbitMQ runs practically everywhere
43. 43
Spring with RabbitMQ
The Spring AMQP project applies core Spring concepts to the
development of AMQP-based messaging solutions
Spring AMQP provides a "template" as a high-level abstraction for
sending and receiving messages
Spring AMQP also provides support for Message-driven POJOs
These libraries facilitate management of AMQP resources while
promoting the use of dependency injection and declarative
configuration
In all of these cases, you will see similarities to the JMS support in
the Spring Framework
The Spring AMQP project consists of both Java and .NET versions
to support simple interoperability between Spring Applications
deployed in both environments
45. 45
Monitoring Today: Different tools for Different Teams
Web Servers App Servers Databases
No monitoring App Infrastructure
Monitoring Tool #2
Database Admins
Monitoring Tool #3
App Support
Monitoring Tool #1
Application
46. 46
Hyperic collects a broad set of application performance data…
Performance
Database
Availability
Performance
Configuration changes
Events
Log entries
Application Frameworks
Application Servers
Web Servers / Caches
Messaging Middleware
Databases
Directory Services
Email Servers
Operating Systems
Virtualization
47. 47
Application Frameworks
Application Servers
Web Servers / Caches
Messaging Middleware
Databases
Directory Services
Email Servers
Operating Systems
Virtualization
… for infrastructure layers from App to ESX
53. 54
Emergence of Platform as a Service (PaaS)
Friction-free deployment
No machines or middleware to manage
Latest high productivity frameworks
Choice of application services
Cloud portability
More responsive to developers
Elastic and dynamically scalable
Improved efficiency
Digest future cloud advances
Cloud portability
Application Developers
“Write code, not tickets”
IT Operations
“IT as a service provider”
Boost
application
velocity
54. 55
Cloud Foundry – The Open Platform-as-a-Service
Private
Clouds
Public
Clouds
Micro
Clouds
.js
GemFire
Services
Other
Services
RabbitMQ
Services
55. 56
Cloud Foundry – Options Available Today
cloudfoundry.org
• Community Driven OSS
project at
www.cloudfoundry.org
• Source code may be
compiled and deployed on
infrastructure of your
choice
• Ideal for enterprises
looking to develop their
own flavor of Cloud
Foundry
• Available Now
Micro Cloud
• Downloadable VM to
run on any computer
or server
• Single developer
instance of Cloud
Foundry
• Ideal for small test/dev
cycles
• Available in Q2, 2011
cloudfoundry.com
• Multi-tenant PaaS for
developers
• Ideal for developers who
need to start app
development right away
• Limited Beta Now
56. 57
VMware’s Open Platform as a Service Strategy
1. Build your application
2. Deploy it
3. Move as needed
Downloadable
Micro Cloud
Cloud FoundryvFabric
Service Provider
Private Cloud
vSphere
Hybrid Cloud
vSphere
vCloud
partners
Cloud FoundryvFabric Cloud FoundryvFabric
Ruby App
Java App
www.cloudfoundry.com
57. 58
App Platform for the Cloud Era: Platform-as-a-Service (PaaS)
Integrated stack for application development
• Simplifies development
• Makes developers more productive by allowing them to focus on code
No upfront investment in infrastructure or technology
• Curated, updated, managed and maintained as a service
• Flexible consumption models keeps cost low
Grows with business
• Elastic to meet the needs of your business no matter what stage of growth
• Elastic scale up and down making management and operations easier
58. 59
Cloud Foundry – The first open platform-as-a-service
Self-service application execution engine
• Build applications with latest high productivity frameworks
Automation engine for deployment and lifecycle management
• Deploy and cloud-scale applications in seconds
Open architecture
• Choice of clouds for deployment
• Choice of industry-standard frameworks
• Choice of application infrastructure services
• Extensible architecture to “digest” future cloud innovation
• Available as open source
60. 61
Cloud Foundry – Optimize Application Delivery
Increase responsiveness while managing risk
• IT can respond to developers’ need for multiple frameworks and programming
languages through curated stack
• With VMware as a trusted partner, there’s no risk to applications and
datacenter
Increase choice while reducing datacenter complexity
• Cloud Foundry’s open PaaS supports multiple frameworks and programming
languages giving developers the choice and flexibility they seek
• Option to use Cloud Foundry in datacenter or private, public or hybrid clouds
gives IT a real option to reduce datacenter complexity
Increase operational efficiency while reducing cost
• Cloud Foundry’s ability to host multiple apps on single VM provide increased
efficiency at lower cost
• Built-in elasticity allows applications to grow or shrink according to user
demand
62. 63
Cloud Foundry – Options Available at Launch
cloudfoundry.org
• Community Driven OSS
project at
www.cloudfoundry.org
• Source code may be
compiled and deployed on
infrastructure of your
choice
• Ideal for enterprises
looking to develop their
own flavor of Cloud
Foundry
• Available Now
Micro Cloud
• Downloadable VM to
run on any computer
or server
• Single developer
instance of Cloud
Foundry
• Ideal for small test/dev
cycles
• Available in Q2, 2011
cloudfoundry.com
• Multi-tenant PaaS for
developers
• Ideal for developers who
need to start app
development right away
• Limited Beta Now
64. 65
WaveMaker Studio
Browser-based design environment
• WYSIWYG, drag & drop UI design
Complete RAD platform
• Bind UI to data services
• Integrate DB & web services
Complete web environment
• Includes Java server (Tomcat)
• Includes testing database (HSQLDB)
Download & run on any computer
• Windows, Mac, Linux
WaveMaker Studio
Database
Web
pages
(HTML, JS)
Web
Services
Java
Code
Security
Service
(LDAP, SSO)
Visual Development of Web Apps!
Browser-based
Drag & drop components
Widgets
Properties
Services
65. 66
WaveMaker Common Artifacts
Visual, drag and
drop development
● DB Schema
● Web Services
● Java classes
● Custom Widgets
● Database schema
● Project zip file
● Custom widgets
● Standard web files:
● index.html
● myproject.js
● myproject.css
● Standard Java file
● myproject.war
Import
Export
Generated App
66. 67
WaveMaker Architecture
Open Source Components
• Dojo: Ajax widgets
• JSON: async messaging
• Spring: Java container
• Hibernate: database access
• JaxWS: web services access
• Spring Security: user authentication
Enterprise Components
• Role-based access, multi-tenancy
• LDAP, JOSSO, SSO
• WebSphere, WebLogic
• Oracle, DB2, SQL Server
WaveMaker JavaScript Widgets
Dojo Toolkit
WaveMaker Framework
HibernateSecurity JAXWS
JSON
Request
Database
WaveMaker Client
WaveMaker Server
Web
pages
(HTML, JS)
JSON data
Response
Custom JavaScript
Custom Java
Spring Framework
Web
Services
Java
Code
Security
Service
(LDAP, SSO)
68. 69
Changes/Trends in Development
1. Move to Agile development
• Tighter collaboration with all
functions, especially IT
• Expanding role of Developer
• Multiple iterations in a release
(versus just one in waterfall)
• Goal: Shippable product at the end
of each iteration
• Continuous integration is now the
norm – build minutes soaring
2. Increased pace of change
• Agile development – “faster time to
failure”
• Pressure for faster time to market
• Prototyping new technologies
3. Higher expectations for software
access
• Develop once, deploy anywhere (multi-
destination, multi-device)
• Rush to “SaaS-ify” existing apps to
satisfy end users’ need for immediate
and consistent access across devices
4. Changing maintenance models
(DevOps)
69. 70
Developers’ Reality
Before building software, developers must first build/integrate their
software development environment:
Choose a version control system for code, plus an issue tracker
Configure continuous integration tool
Decide where to keep documentation and how to collaborate with team
members – assign roles and access
And maintain it going forward…
Monitor security, availability, access, upgrades/compatibility of all components
70. 71
Code2Cloud: Development in the New World
Code2Cloud provides a hosted ready-to-use platform for software
development, so developers can forget about integrating and
maintaining their tools and focus on building great software.
1 2 3
Create an
Account
Create a Project
Start Using Your Project:
Everything There for You
71. 72
Code2Cloud – What’s in it?
Critical developer services – provided in a single, ready-to-use hosted
environment with enterprise-level security and uptime
Comprised of popular open source developer tools and services;
Code2Cloud application will also be open sourced (Apache 2)
Ability to publish to Cloud Foundry, tcServer, VMforce (more coming…)
Code2Cloud
Source Code Control
Git
Continuous Integration
Hudson
Task Management
Mylyn
Bug and Issue Tracking
Bugzilla-compatible
Documentation
Mylyn WikiText
Team Mgmt & Activity
Dashboarding
Publish App to Cloud Foundry, tcServer, VMforce
(more to come)
Code2Cloud
application binds,
provisions, and
orchestrates all
components.
72. 73
Code2Cloud – Web Interface
All project
components
are
integrated
and easily
accessible.
74. 75
Code2Cloud: Dev / Test Services in the Cloud
CloudFoundry
vFabric Partner
Clouds
vFabric
on-premise
Browser
Developer Dev / Test Services Deployment Platforms
• Developer artifacts
• Collaboration
• Service Registry
• Common Objects
Non-coders
Source Code Control
Git
Continuous Integration
Hudson
Task Management
Mylyn
Bug and Issue Tracking
Bugzilla-compatible
Wiki
Powered by Mylyn WikiText
76. 77
Spring Core
Problem: EJBs lack the APIs needed to build fully functional,
enterprise applications, and they are not TDD friendly or lightweight.
Solution: One-stop-shop for building enterprise ready applications.
Acronym Meaning
IoC Inversion of Control
DI Dependency Injection
MVC Model, View,
Controller
AOP Aspect Oriented
Programming
77. 78
Spring Integration
Problem: An enterprise service bus (ESB) is often
overkill for most application integration scenarios.
Solution: Extend the Spring programming model
to deliver EIP (Enterprise Integration Patterns)
Pattern Description
Splitter Split one message into multiple
messages
Aggregator Combine multiple messages into a
single message
Wire Tap Inspect point to point messages
CBR Route a message based on content
Transformer Transform message content into a
different form
78. 79
Key Features
Allows you to add an integration layer to your app
• An embedded message bus that runs within any Spring ApplicationContext
where all components are Spring beans
• Endpoints delegate to Spring-managed beans, framework handles message
reception and method invocation
Comprehensive support for EIP
• Channel, Router, Filter, Transformer, Splitter, Aggregator
• High-level configuration DSL built around these patterns
Provides a portable abstraction across multiple channel adapters
• AMQP, JMS, File, Mail, HTTP, FTP
Support for asynchronous / parallel workloads
• Point-to-Point and Publish-Subscribe Channels
• Polling and Event-Driven Message Endpoints
79. 80
Spring Batch
Problem: Move batch jobs off of the mainframe and onto
commodity systems with a well known, trusted Java API.
Solution: Extend the Spring programming model to
deliver batch jobs on x86 and a lightweight runtime.
Pattern Description
Small Single Chunk Simple, stateless jobs
Small Chunked Transaction per chunk and stateful
Large, single platform Use Spring Integration to process partitions on
separate threads
Large, multiple
platform
Use Spring Integration to process partitioned data on
JMS queues and deliver elastic scaling
80. 81
Key Features
Repeat and retry operations
Support for flat files, XML streaming, & DB queries
Well-defined domain for:
• Jobs – list of steps
• Step – reader/writer wrapper
• Factory beans for fault tolerance – retry, skip
Job execution and management
• Simple JobLauncher that can be initiated via JMX, command line or scheduler
• Persistence of job meta-data
• Branching and decision support for non-sequential jobs
Remote chunking and Partitioning support
• Master-Slave compute grid processing in distributed data partitions
82. 83
Where to Start?
High Volume Web Apps
Mobile and Multi-Device
Next-generation Integration
Modern Batch Processing
Modern
Cloud-friendly
Applications
High
Performance
Data
Low-latency Data Management
Distributed Data Grids
High-scale In-memory Data Processing
Platform
as a
Service
Simple, Self-service
Application Platform
Optimize App Velocity
Increase App Efficiency
Hinweis der Redaktion
To address this challenge, VMware is focused on three core solution areas in IT:
How best to evolve the infrastructure to support this new world,
Changes in application development to speed time-to-market for business-critical applications, that take advantage of this new world,
And a new way of approaching end-user computing, to increase user satisfaction.
<click>
Let’s begin by exploring the evolution of infrastructure.
Rails = framework for Ruby
Django = framework for Python
Point to emphasize: in the past, middleware has run on physical servers. Today, it’s increasingly shifted to running on VMs. And that brings about a compelling opportunity for VMware and its partners.
Note: a la carte SKUs are still available to sell.
Q. How is vFabric 5 Engineered for vSphere?
Optimizations for vSphere include:
Elastic Memory for Java (EM4J), which allows for dramatically higher consolidation ratios for Java applications running on vFabric. EM4J pools Java heap memory across tc Server instances running on the same vSphere host, enabling a tc Server that is under memory pressure to borrow Java heap memory from its neighbors. This enables application teams to size Java heaps according to typical workloads, not peak workloads, which in turn lets them create VMs with smaller memory footprints, and pack more tc Server instances onto a single vSphere host. It also reduces the likelihood of out of memory errors that can cripple applications.
Java Best Practice Analyzer, a vSphere client plug-in which enables vSphere administrators to view and controls settings on the vSphere virtual machine, guest operating system, and Java virtual machine (JVM) that can impact Java application performance. Java Best Practice Analyzer identifies common configuration and deployment problems that can cause slow Java performance on vSphere.
Q. How is vFabric 5 Engineered for Spring?
Optimizations for the Spring Framework include highlights such as Spring Insight Operations which allows unparalleled visibility into the performance of Spring applications. Spring Insight Operations features:
Easy, automatic instrumentation of Spring applications running on tc Server to enable app operations teams to view application performance both at overview and fine-grained perspectives.
Isolation of performance problems by application, endpoint, application server, and method.
Tracking of performance over time, to understand whether problems are chronic or spurious.
Response time histograms, to understand whether performance problems affect a large portion of users, or a small subset.
Highly performant instrumentation with sub microsecond impact to application response time, allowing it to be run on applications in production
Hyperic integration, enabling allows the Operations and Development teams to view a single set of both server-oriented and application oriented performance, and collaborate more effectively to fix performance problems faster. Metrics from Spring Insight provide Hyperic with a broader range of data for triggering alerts for sysadmin notification, and control actions for automatic problem remediation.
Parallel deployment is explained at http://www.tomcatexpert.com/blog/2011/05/31/parallel-deployment-tomcat-7. From that blog post:
Upgrading web applications can be very expensive if your storefront is the web. Weekend maintenance windows, or downtime in general can give an entire company heartburn. Survey data shows that web application downtime can cost some companies up to $72,000. Yet the cost of not constantly rolling out new features and bug fixes can equally penalize a company in the competitive online markets today.
Previously, to upgrade an application on Tomcat and avoid downtime, system administrators would have to set up multiple instances of Tomcat and do some very clever stuff with load balancers. This equals extra hardware costs as a permanent part of the company’s infrastructure.
Now with the advent of parallel deployment in Tomcat 7, you can have multiple versions of the same application installed at the same time on a single server. Users with active sessions can continue to use the old application and new users will be routed to the new version. This way, no user sessions will be interrupted, and the old application can gracefully phase out.
Setting Up Parallel Deployment
Parallel deployment is a function of the Context Container. The Context element represents a web application, which in turn specifies the context path to a particular Web Application Archive (WAR) file that is the application logic. Parallel deployment allows you to deploy multiple versions of a web application with the same context path concurrently. When choosing what version of the application for any given request, Tomcat will:
Route new requests to the latest version, so new sessions go to the new application.
If session information is in the request, check the session manager for a matching version, so existing sessions will go to the original application for the request.
If session information is in the request, but the corresponding application is no longer present, it will route to the latest version.
Working Across Clusters
If you have clustered Tomcat, configured using the FarmWarDeployer, you can achieve parallel deployment within that cluster. The FarmWarDeployer is a component which lets you deploy a WAR file across an entire cluster. By placing the WAR file on the designated host, clustered Tomcat will automatically replicate that deployment across every server in the cluster.
Footnote
Because of the sophistication and cost savings this feature brings to enterprise deployments of Tomcat, this feature, built by VMware’s SpringSource, was initially looked at being part of VMware vFabric's tc Server, but once we got building it, it couldn’t be done cleanly without putting some hooks into Tomcat that didn’t fit naturally into the architecture. After careful consideration of what was best for Apache Tomcat, VMware decided to still fill the need to build this feature out, but donate it to the Apache Tomcat project at large.
Use 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:
Customer is creating a true data grid: lots of clients, connecting to many nodes, some of which may cross WAN’s
The 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 reliability
The 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 altogether
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 throughput
Scenario 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.
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.
Session replication and L2 cache without turning app servers into stateful servers.
C/S is essentially all the benefits of a database without the drawbacks. Database capabilities in-memory
Access to the more sophisticated GemFire features - data-aware function routing,
Spring Framework 3.1 introduces a caching abstraction via the @Cacheable annotation for incorporating pluggable caching strategies into applications. The @Cacheable annotation uses Spring AOP and AspectJ under the covers.
The following swappable distributed caches are built in: Ehcache, Coherence, GigaSpaces, and GemFire
For cluster status and performance monitoring, use GemFire tools
Hyperic can manage
JMX Agent
Gateway Hub 6.5
Cache Server 6.5
Application Peer 6.5
Recommended Forrester Reading:
Lean Software Is Agile, Fit-To-Purpose, And Efficient; Dec 12 2008
Lean: The New Business Technology Imperative, Sep 29 2009
Although Spring is famous for its openness and portability, we can take advantage of our deep understanding of Spring to add unique value for applications running on the vFabric platform.
Spring Insight is a technology that provides code level tracing – tracking the time a transaction spends in each method and JDBC (database) call – transparently for Spring Applications. Basically, users get very deep information on the operation of a running Spring application just as a benefit for running in on vFabric. No code modifications or setup is required.
Spring Insight has been available for developers for almost a year as part of the tc Server Developer Edition. This is a single-user, development-time solution that integrates helps developers find performance bottlenecks in their applications while running it on their local machines, typically inside our Eclipse-based IDE, SpringSource Tool Suite.
Next year we will roll out Spring Insight Enterprise, which leverages the same code-level tracing technology but pulls together information from multiple application servers into a single console with roll-up views, drill downs, and historical comparisons. This solution has been designed to minimize the overhead of the monitoring so it is suitable for both test and production environments.
While the Spring Insight Enterprise console is useful for both administrators and developers who may need to troubleshoot problems in production, it is also important that administrators and operations have a single place to go for vFabric monitoring. Therefore, Spring Insight Enterprise monitoring will be available not only as a stand-alone console but also through a plug-in to the Hyperic monitoring solution, enabling a single view across data from multiple sources and integrated alerting and control actions.
Over the past year, we have invested a lot of effort in providing automatic visibility into Spring applications so that our customers can answer important questions about the behavior of their applications.
In this particular example, we have a Hotel Booking application. By using the Spring Insight technology baked into our application platform, our customers can interact with a chart that illustrates how their application is performing and whether or not the response times are within the expected SLAs.
If there is an issue, they are able to drill into the application further. Let’s say that certain response times for finding and displaying available hotel rooms look out of band…well, you can selectively drill into that request and see if the database is the bottleneck, for example.
This level of visibility helps developers create high performing applications, but as we will cover in a moment, this information combined with visibility across the application infrastructure stack is also critical for delivering the proactive performance management required of today’s modern platforms.
1. Optimized for Spring applications and tc Server. Easily installation and automatic instrumentation for Spring applications running on tc Server, in-depth tracing through endpoints in complex transactions.
2. Multi-user, multi-application, and multi-node clusters - UI is designed to view aggregate and individual metrics and traces by applications, servers, and end points.
3. Highly performant instrumentation with sub microsecond impact to application response time, allowing it to be run on applications in production (I would like to use this to lead the performance impact discussion).
4. Easily customizable thresholds for end points to have a more accurate reporting of apdex score and overall application health.
5. The Hyperic integration allows the Operations and Development teams work more closely together on actual production data. The addition of Spring Insight data makes it easy for an operations person to have quicker root cause identification and involve the developers earlier in a more timely manner. Hyperic adds to Insight the ability to alert on and correlate its data to Hyperic's application infrastructure resources and metrics.
--
New features in Spring Insight 1.5.1 over 1.0
- Production agent/dashboard deployment is the big feature ( the 1.0 release was developer-only )
- Updated to spring 3.0/tomcat 7
- Data persistence - 1.0 didn't save data to disk
- Much better UI over 1.0
- Ability to mark certain code paths as "sensitive" to prevent them from being sent to the dashboard.
- GoogleSpeedTracer was emphasized in the 1.0 release, it still works, but we have emphasized it less. Worth a mention.
One of the most common challenges facing anyone running a Java application is figuring out how much memory to give it. Since Java heaps are static, giving too much memory can be very wasteful, and can sometimes even lead to poor performance through long GC (garbage collection) pauses. Conversely, if a JVM does not have enough memory the application will encounter an out-of-memory exception and simply crash.
It would be very useful to have a way to give a little extra memory to a JVM with the understanding that, when it is not needed, the memory will be reclaimed into a common pool. But if the Java application encounters a spike, its full memory assignment will be available to it.
Of course, ESX already has ways to reclaim and then give back memory to virtual machines at the OS level, so what we need here is an extension of that technology that operates at the Java level. The vFabric platform will be offering exactly that capability, working with some new capabilities to be introduced in ESX. We call the technology Elastic Memory for Java or EM4J.
Elastic Memory for Java is an agent that runs directly inside Java and manages memory within the Java heap. When Java is lightly loaded, the agent allocates objects onto the heap, creating a “balloon”. The memory associated with these objects is then passed to ESX, which is then free to give this memory to other virtual machines that need memory more urgently.
When Java is under heavy load, the balloon is deflated and Java has all the memory it needs to handle heavy load.
When running a vFabric application on top of vSphere, it is natural to ask: how do I make sure that I am following best practice? New technologies like EM4J promise to make the applications run even better than before on vSphere. But again: how do I make sure that I understand what EM4J is doing and make sure that everything is set up right?
The trickiest part of following best practice for Java applications is that, while some of the required configuration is at the vSphere or VM level, other items require insight into Java configuration. So how can a vSphere admin know that things are set up right – and that they stay that way?
The vFabric Java Best Practice Analyzer is a vSphere client plug-in that gives vSphere admins a simple interface to check that both the Java-level and VM-level best practices are being followed. And if they aren’t, tell them exactly what to do about it. In addition, the Best Practice Analyzer gives vSphere admins a view into, and control over, the operation of EM4J.
Note that while the initial focus of the best practice analyzer will be on the vFabric Java runtime container, tc Server, it will expand over time to support other application servers.
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.
Design guidance from http://redis.io/
Note that “easy to use” isn’t in this copy. That’s because it’s implied with the tagline “messaging that just works” and the extensive list of tutorial links.
45
46
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-technologies
To view the metrics that Hyperic supports:
Log into Hyperic
Administration tab
Click “Monitoring Defaults”
Select the technology of interest
Click “Edit Metric Template”
As we think about it from an enterprise perspective, Cloud Foundry is an opportunity to boost application velocity through systemic productivity improvements across the entire dev and ops pipeline. Developers can focus on the app while IT delivers the platform as a service. PaaS speeds up prototyping, trial, testing, scale testing, production, updating, cloud-scaling apps.
Add: cloud foundry inside vFabric
Target destination of cf.com
Add other providers running cloud foundry
Add other languages…ruby
Developers and IT get curated, updated and operated applications infrastructure need not be upgraded or patched