<Insert Picture Here>
Oracle Cloud Strategy: Oracle’s Vision for Next-Generation Application Grid, Virtualization and Clou d
Paolo RamassoMaster Principal Sales Consultant Oracle Italy
Business Imperatives and Challenges
Efficiency: expand despite constraints Flexibility&Agility: despite constraints Flexibility&Agility:
change course quickly
Quality of service: rise above the competition
4/27/2010 3©2008 Oracle Corporation
The Old WayThe Old Way
Grid Computing Virtualizes and Pools IT Resources
Getting Startedwithwith
Cloud
What’s Different about Cloud?
Users expect a cloud infrastructure to support*:
1. The illusion of infinite computing resourcesinfinite computing resources available onon--demanddemand• Capacity always needs to be there through automation and
proactive operations before users perceive a constraint (“infinite”)• Users need to be able to self-serve (“on-demand”)
2. The elimination of up-front commitment by users• Fine-grained, actual usage/allocation-based chargeback rather
than purchase ahead of time (“no up front commitment”)
3. The ability to pay for use of computing resources on a short-term, as-needed basis• Dynamic capacity management scale up or down (“short-term /
no commitment”)
*Paraphrasing UC Berkeley Reliable Adaptive Distrib uted Systems Laboratory (http://radlab.cs.berkeley. edu/)
© 2009 Oracle – Proprietary and Confidential 7
SaaS, PaaS and IaaS
Applications delivered as a service to end-users over the Internet
Software as a Service
App development & deployment
Infrastructure as a Service
Platform as a ServiceApp development & deployment platform delivered as a service
Server, storage and network hardware and associated software delivered as a service
Public Clouds and Private Clouds
INTERNET
Public Clouds
IaaS
PaaS
SaaSINTRANET
Private Cloud
• Used by multiple tenants on a shared basis
• Hosted and managed by cloud service provider
• Exclusively used by a single organization
• Controlled and managed byin-house IT
• Large number IaaS
PaaS
SaaS
T T
Users
Public Clouds:• Lower upfront costs• Economies of scale• Simpler to manage
Private Cloud:• Lower total costs• Greater control over security,
compliance & quality of service• Easier integration
Both offer:• High efficiency• High availability• Elastic capacity
provider
• Limited variety of offerings
• Large number of applications
Build Your Own Private PaaS Clouds with Oracle Technology
Adding…
• Flexibility
• Agility
…through virtualization
• Across the stack
On demand
• metering
• Billing
The Grid
Grid&Virtualization
Self-Service Provisioning
Applications
Resources that are…
• Distributed
• Scalable
• Highly Available
…through virtualizationThe Grid
Real Application Clusters
Mid-Tier Server ClustersPhysical Pools
Virtual Machines
Physical Pools
Virtualization
OS
Database
Middleware
WLSWLS
WLS
WLS WLS
WLS
WLS
WLS
App Svr App Svr
App Svr
App Svr
App Svr
App Svr
App Svr App Svr
App Svr
App Svr
1: Leverage Application ServerBuild foundation for efficiency and scalability
4/27/2010 ©2008 Oracle Corporation 11
•Use application server clustering for scale-out
Possible actions:
•Consolidate to WebLogic Server (or Tuxedo for C/C++ /COBOL)
•Use scripting to automate scaling
CoherenceCoherence
CoherenceCoherence
JRockit JRockit
2: Enhance Scalability and PerformanceMake your infrastructure more dynamic and resilient
App Svr App Svr
App Svr
App Svr
App Svr
App Svr App Svr
App Svr
CoherenceCoherence
4/27/2010 ©2008 Oracle Corporation 12
•Add Coherence in-memory data grid to existing machi nes
Possible actions:
•Add Coherence nodes on non-app-server machines
•Add JRockit Real Time JVM
3:Enhance Agility Adding Virtualization
Application 1 Application 2 Application 3
Application Grid: WebLogic Server, Coherence, Tuxedo, JRockit
Shared Services
Integration:SOA Suite
Security:Identity Mgmt
Process Mgmt:BPM Suite
User Interaction:WebCenter
Platform as a Service Cloud Management
Lifecycle Management:
Configuration Mgmt:Discovery, Gold Templates,
Change Detection,Rollback, Compliance
Oracle Enterprise Manager
© 2009 Oracle – Proprietary and Confidential 13
Virtualization: Oracle VM
Operating Systems: Oracle Enterprise Linux
Servers
Storage
Database Grid: Oracle Database, RAC, ASM, Partitioning,IMDB Cache, Active Data Guard, Database Security
Infrastructure as a Service
Application QualityManagement:
Testing,Patch Management
Application PerformanceManagement:
RUEI, SLA Managment,Monitoring, Diagnostics
Lifecycle Management:Provisioning,
VM Templates,Large-Scale Automation
Oracle Virtual Assembly Builder Package Multi-Tier Applications
Oracle WebLogic Suite -based Application Grid
Oracle WebLogic Suite-based Application Grid
Oracle SOA Suite
Oracle BPM Suite
Oracle WebCenter
Oracle Identity
Mgt
Oracle Database
Introspection&
Application A Application B
Virtualized
Enterprise M
anager
Assembly Builder
Assembly Builder
Deployment
& Assembly
Oracle VMTemplateBuilder
OVF Packaging
Oracle VM Server
VirtualizedSoftware
Appliances
Enterprise M
anagerO
racle VM
Manager
Assembly A Assembly B
Oracle Virtual Assembly Builder Tool
Assemblies,Appliances
Catalog
PropertiesInspector
Deployment Resource
Pools
Assembly Editor
Private PaaS Lifecycle
App Developer
App Users
2. Build App
3. Use App
4. Scale up/down
App
• Assemble app using shared components
• Deploy through self-service
• Adjust capacity based on policies
• Monitor via self-service
App Owner 5. Chargeback• Meter usage
and charge
Self-Service InterfaceShared Components
• Set up PaaS• Set up shared
components• Set up self-
service portal
IT
1. Set Up Cloud
and charge back to app owners or departments
Oracle VM
Oracle Enterprise Linux
Oracle Database
Oracle Fusion Middleware
Oracle Enterprise Manager
Cloud Computing with Oracle with Oracle
Fusion Middleware
JRockit GC Latency Management
0
15
30
45
60
75
90
105
120
0 2000 4000 6000 8000 10000 12000 14000 16000 18000
During Low Load: GC spikes and occasional timeouts visible
Traditional JavaJRockit Real Time
and occasional timeouts visible
During High Load: GC pauses can result in unacceptable response times
0
15
30
45
60
75
90
105
120
0 2000 4000 6000 8000 10000 12000 14000 16000 18000
JRRT Makes garbage collection deterministic. Allowing for the guarantee of SLAs.
Traditional Scale-Out Approaches…
#1. Avoid the challenge of maintaining consensus• Opt for the “single point of knowledge”
#2. Have crude consensus mechanisms, that typically fail and result in data integrity issues (including loss)
Client + Server Model(Hub + Spoke)
Master + Worker Model(Grid Agents)
Active + Passive(High Availability)
Oracle Coherence Data Grid
• Provides a reliable data tier with a single, consistent view of data
• Enables dynamic data capacity including fault tolerance and load
Enterprise Applications
Real TimeClients
WebServices
Oracle Coherence
Data Services
Distributed in Memory Data Management
including fault tolerance and load balancing
• Ensures that data capacity scaleswith processing capacity
MainframesDatabases Web Services
Oracle CoherenceData Grid
The Coherence Approach…
• Traditional scale-out approaches limit• Scalability, Availability, Reliability and Performance
• In Coherence…• Servers share responsibilities (health, services, data…)• No SPoB • No SPoB • No SPoF• Massively scalable by design
• Logically servers form a “mesh”• No Masters / Slaves etc.• Members work together as a team
Data Grid Uses
CachingApplications request data from the Data Grid rather than backend data sources
AnalyticsApplications ask the Data Grid questions from simple queries to advanced scenario modelingadvanced scenario modeling
TransactionsData Grid acts as a transactional System of Record, hosting data and business logic
EventsAutomated processing based on event
Coherence in the Application-Tier
Coherence in the Application Tier: .NET/C++/Java (Wan) Clients
OAS, WebSphere, JBoss … OAS, WebSphere, JBoss …
Partitioned Topology : Data Access
• Coherence provides many Topologies for Data Management
• Local, Near, Replicated, Overview, Disk, Off-Heap, Extend (WAN), Extend (Clients)
Data Access Topologies
• Data spread and backed up across Members
• Transparent to developer
• Members have access to all Data
• All Data locations are known – no lookup & no registry!
Partitioned Topology
Partitioned Topology : Data Update
• Synchronous Update
• Avoids potential Data Loss & Corruption
• Predictable Performance
• Backup Partitions are partitioned away from Primaries for resilience
• No engineering requirement
Partitioned Topology
• No engineering requirement to setup Primaries or Backups
• Automatically and Dynamically Managed
Partitioned Topology : Recovery
• Membership changes (new members added or members leaving)
• Other members, in parallel, recover / repartition
• No in-flight operations lost
• Some latencies (due to higher priority of recovery)
Partitioned Topology
higher priority of recovery)
• Reliability, Availability, Scalability, Performance are the priority
• Degrade performance of some requests
Partitioned Topology
• Deterministic latencies for data access and update• Linearly scalable by design• No TCP/IP connections to create / maintain• No loss of in-flight operations while repartitioning• No requirement to shutdown cluster to • No requirement to shutdown cluster to
• recover from member failure• add new members• add named caches
• No network exceptions to catch during repartitioning• Dynamic repartitioning means scale-out on demand
Partitioned Topology : Local Storage
• Some members are temporary in a cluster
• They should not cause repartitioning
• Repartitioning means work for the other members (and network traffic)
• So turn off storage!
Partitioned Topology
• So turn off storage!
Topology Composition : Near Topology
• Coherence allows Topologies to the Composed• Base Topologies
• Local, Replicated, Partitioned / Distributed, Extend
• Composition Topologies• Near, Overflow…
• Near Topology• Compose a Front and a Back Topology• Permit L1 and L2 caching• Both Front and Back may be completely different• Both may have different Expiry Policies
• Expiry Policies• LRU, LFU, Hybrid, Seppuku, Custom…
Topology Composition : Near Topology
PIF/POF
• POF (Portable Object Format) is the language independent serialization format used by Coherence*Extend
• PIF (Portable Invocation Format) is a language independent remote method invocation. All Coherence*Extend protocol messages are PIFs (e.g. Coherence*Extend protocol messages are PIFs (e.g. GetRequest) which are nothing more than a POF preceeded by a conversation identifier (a POF integer value)
Credit for the name belongs to Gene Gleyzer: The phonetic origin of PIF-POF is from Russian language comic strips, in which “piff-paff” (pronounced “peef-puff”) is the equivalent of the English “bang-bang” – the sound of a gun.
Features : Traditional
• Implements Map interface• Drop in replacement. Full concurrency control. Multi-
threaded. Scalable and resilient!
get, put, putAll, size, clear, lock, unlock…
• Implements JCache interface• Extensive support for a multitude of expiration policies,
including none!
• More than “just a Cache”. More than “just a Map”
Features : Observable Interface
Full Example// listen for insert events on Person
// This can be done in an easier way by using a new AbstractMapListener()
// and then overriding only the method you want to
//
person.addMapListener(new MapListener()
{
public void entryDeleted(MapEvent mapEvent) {
// ignore
}
public void entryInserted(MapEvent mapEvent) {public void entryInserted(MapEvent mapEvent) {
Person p = (Person)mapEvent.getNewValue();
System.out.println("New person added: " + p.getFirstname() + " " + p.getSurname());
}
public void entryUpdated(MapEvent mapEvent) {
// ignore
}
}
);
Features : QueryMap Interface
Features : QueryMap Interface
• Find Keys or Values that satisfy a Filter. entrySet(…), keySet(…)
• Define indexes (on-the-fly) to extract and index any part of an Entry
• Executed in Parallel
• Create Continuous View of entries based on a Filter with real-time events dispatch• Perfect for client applications “watching” data
Features : InvocableMap Interface
Features : InvocableMap Interface
• Execute processors against an Entry, a Collection or a Filter• Executions occur in parallel (aka: Grid-style)• No “workers” to manage!
• Processors may return any valuetrades.invokeAll(trades.invokeAll(
new EqualsFilter(“getSecurity”,“ORCL”),new StockSplit(2.0));
• Aggregate Entries based on a Filterpositions.aggregate(
new EqualsFilter(“getSecurity”,“ORCL”),new SumFilter(“amount”));
Coherence as a Separate Tier with FMW
WebCenter IDM
Firewall Firewall Firewall
ExternalUsers
InternalUsers
Java EE
SOACoherence Data
Grid Service
Web
Tier RAC
RouterInternet
InternalUsers
InternalUsers
Maximum Availability ArchitectureActive/Active
WebTier
Firewall
Global Router
Firewall
WebTier
Firewall
ActiveData Center 2
Firewall
Low Latency High
ActiveData Center 1
WebCenter
IDM
RA
CSOA J2EE
Firewall
WebCenter
IDM
RA
C
SOA J2EE
Firewall
Coherence Data Grid Service
High Bandwidth
WAN
Passive
OracleAS Guard
Oracle WebLogic Server
• The Number #1 Java EE application server, designed for the most Mission-Critical of applications
• Developer-friendly – productive, standards-based development• Focus on quality of service – performance, scalability,
reliability, availability• Built-in manageability – configuration, monitoring , diagnostics,
maintenancemaintenance
WebLogic Server Clusters
WebLogic Application Grid
Databases MainframesLegacy Commodity Virtualized
WebLogic Server Virtual Edition:Less Is More
Management Simplicity with Performance and Utilization
APPAPP
WebLogicWebLogic
JRockitJRockit
WLS-VEWebLogic Server
JRockit VE
Server
Server
OSOS
APPAPP
WebLogicWebLogic
JRockitJRockit
Oracle VMOracle VM
OSOS
Oracle VMOracle VM
Server
LVMLVM
APPAPP
WLSWLSVEVELVMLVM
APPAPP
WLSWLSVEVE LVMLVM
APPAPP
WLSWLSVEVELVMLVM
APPAPP
WLSWLSVEVE
OSOS
APPAPP
WebLogicWebLogic
JRockitJRockit
OSOS
APPAPP
WebLogicWebLogic
JRockitJRockit
WebLogic Server Virtual EditionValue Proposition
• Management Simplicity• Eliminate requirement for provisioning and managing
Guest Operating Systems• Only application administration, no separate OS
administration• Assembly Builder delivers simplified deployment of entire
domain onto virtualized resources
WLS-VEWebLogic Server
JRockit VE
domain onto virtualized resources
• Higher Performance• Tailored to run Java (Only the bare minimum of OS
services needed for java)• Optimized to run on Virtual Platforms
• Better physical hardware utilization• Eliminating the OS reduces consumption of system
resources such as memory and CPU cycles
Engine Tier
WLS
Coherence*Web
New for 11 g: ActiveCache
• Direct integration with HTTP container and TopLink ORM• Use standard JavaEE APIs
• Ideal for applications with • large data objects
WLS
Coherence*Web
WLS
Coherence*Web
client
Transient Data Tier
• large data objects• memory constraints• volatile scaling needs
• Foundation of Application Grid performance and reliability
• Easy to use, deploy, manageCoherence
CoherenceCoherence
CoherenceCoherence
Typical WebLogic Server Cluster
RDBMSRDBMSSessionsSessionsHTTP/JSPHTTP/JSP EJBEJB
WebLogic Server
SessionsSessionsHTTP/JSPHTTP/JSP EJBEJB JDBCJDBC
JDBCJDBC
Load Balancer
HTMLHTML
Application Server Tier
WebLogic Server
SessionsSessionsHTTP/JSPHTTP/JSP EJBEJB
WebLogic Server
JDBCJDBC
Oracle Web Tier – Web Cache
HTMLHTML
WebLogic Server with Coherence*WebSeparate traffic processing, session management
Coherence
Sessions and CacheSessions and Cache
RDBMSRDBMS
Coherence
Sessions and CacheSessions and Cache
WebLogic Server
ServletServlet EJBEJB JDBCJDBCLoad Balancer
Engine Tier State Tier
RDBMSRDBMS
Coherence
Sessions and CacheSessions and Cache
Coherence
Sessions and CacheSessions and Cache
WebLogic Server
ServletServlet EJBEJB JDBCJDBC
Oracle Web Tier – Web Cache
HTMLHTML
New in 11g: GridLink for RACSupport for Oracle RAC Services
• New supported configuration for Oracle Database Services
• Based on existing WebLogic Multi DataSource support
• One DataSource for each RAC instance
• Simplify administration when using DB Services
Managed Server
Managed Server
WebLogic Cluster
WebLogic Domain
Multi Data Source (PAY)
Multi Data Source (CRM)Services
• DataSources for activated/deactivated as RAC Services reconfigured
• No App Server/DB Admin synchronization requires
• Load balancing, failover, transactions supported
• Same as in WebLogic Server 10.3 and prior releases
CRM CRM PAY
Shared Storage
RAC Node 1
RAC Node 2
RAC Node 3
(PAY)(CRM)
DS1 DS2 DS3 DS1 DS2 DS3
Oracle RAC Cluster
Enterprise Grid Messaging in 11gR1Oracle AQ JMS Integration
• Oracle AQ JMS implementation • Messaging implementation based on Oracle DB• Standard JMS API with messages persisted to Oracle DB• Can leverage DB features (triggers, stored procedures)• Used widely in Oracle installed base
Oracle Fusion Middleware 10gR3Oracle Fusion Middleware 10gR3
OC4J/Oracle Application Server, BPEL PM, SOA Suite…
AQ JMS API
JDBC
Oracle AQ DBMS Store
Self-Tuning and Work ManagersWebLogic's Self-Tuning Thread Pool
Network Socket Handlers(“Muxers”)
Request Queue
Self TuningThread Pool
• Active• Standby• Stuck• Hogging
Asynchronously dispatched workfrom WebLogic kernel, subsystem,or application
1. Monitor rate ofrequest processing
2. Adjust thread poolsize accordingly
High Availability ApplicationsZero Down Time Application Deployment
• Application versions run side-by-side in same JVM
• Controlled test mode and automated
Existing External Client Connections
New External Client Connections
New Application New Application VersionVersion
Retiring Application Retiring Application VersionVersionand automated
rollback• Automatic retirement:
graceful quiescence or timeout
• Ensures continuity of in-flight transactions
Managed WebLogic ServerSingle Java VM
VersionVersion VersionVersion
Administrative Test Client Connections
Test First inAdministrative
Mode
Lightweight, Testable Plain Java Objects
• Less configuration complexity
• Easier testability and alignment with OS tools• Ant / Maven / Hudson
• Java EE 6.0 makes
Context Dependency & Injection
JSF2
EJB 3.1
Facelets
JSR 330
Presentation
Dependency Injection
Business Services
• Java EE 6.0 makes advances in this area• (CDI) Context and
Dependency Injection• EJB3 JPA• JSF 2.0 (Beans, etc)• Java EE will only
continue to improve
52©2010 Oracle Corporation
Managed Beans
JPA 2
EJB 3.1
JAX-RS
JAX-WS
Persistence
Basic Component
REST
SOAP
DBWSDBWSSDOSDOEISEISMOXyMOXyJPAJPA
Java SEJava SE Java EEJava EE OSGiOSGi SpringSpring ADFADF
The Persistence RI for Java EE 6:
Eclipse Persistence Services Project (EclipseLink)
XML Data Legacy SystemsDatabases
53©2010 Oracle Corporation
• Larger application clusters can lead to database bottlenecks with traditional JPA scaling approaches like:• Adding nodes to a cluster• Tuning database performance to reduce
query time
TopLink Grid: Removing Database Bottlenecks
App TierClusters
• Prior to TopLink Grid, there were two strategies for scaling JPA applications into a cluster:• Disable Shared Cache• Cache Coordination—communicate
changes via messaging
54©2010 Oracle Corporation
Data TierDatabase
TopLink Grid with Coherence CacheApplication
EntityManager
L1 Cache
Application
EntityManager
L1 Cache
EntityManagerFactory EntityManagerFactory
Coherence
55©2010 Oracle Corporation
TopLink Grid —Grid Cache
• Ensures all nodes have coherent view of data.• Database is always right• Shared Cache is always right—Entities read, modified, or created
are available to all cluster members.
• Updates no longer cost n2 as not all members are messaged—minimum communication is to primary and backup nodes.minimum communication is to primary and backup nodes.
• Coherence cache size is the sum of the available heap of all members—larger cache size enables longer tenure and better cache hit rate
• Can be used with existing applications and all EclipseLink performance features without altering application results
Grid Cache—Reading Objects
1. Queries are performed using JPA em.find(..) or JPQL.
2. A find() will result in a get() on the appropriate Coherence cache. If found, Entity is returned. Entity is returned.
3. If get() returns null or query is JPQL, the database is queried with SQL.
4. The queried Entities are put() into Coherence and returned to the application.
Grid Cache—Writing Objects
1. Applications persist Entities using standard JPA and commit a transaction.
2. The new and/or updated Entities are inserted/updated in the database and the in the database and the database transaction committed.
3. If the database transaction is successful the Entities are put() into Coherence which makes them available to all cluster members.
Grid Read
• In the Grid Cache configuration, all reads (both pk and non-pk) are executed against the grid (by default).
• For Entities that typically:• Need to be highly available• Must have updates written synchronously to the database; database
is system of recordis system of record
• Features:• Database is always correct—committed before grid updated• Supports all EclipseLink performance features (including batch
writing, parameter binding, stored procedures, and statement ordering).
• High performance parallel JP QL query execution• Can be optionally used with CacheLoader.
Grid Read —Reading Objects
1. Queries are performed using JPA em.find(..) or JPQL.
2. JQPL will be translated to a Coherence Filter and used to query results from Coherence. A find() will result in a get() on the result in a get() on the appropriate Coherence cache.
• The database is not queried by EclipseLink.
• If Coherence is configured with a CacheLoader then a find() may result in a SELECT, but JQPL will not.
Grid Read —Writing Objects
1. An application commits a transaction with new Entities or modifications to existing Entities.
2. EclipseLink issues the appropriate SQL to update the database and commits the database transaction.
3. Upon successful commit, the new and updated Entities are put() into Coherence.
Grid Entity
• The Grid Entity configuration is the same as the Grid Read configuration except that all writes are executed against the grid, not the database.
• With this configuration Coherence is effectively the "system of record" as all Entity queries are directed to it rather than the database.
• For Entities that typically:• For Entities that typically:• May have updates written asynchronously to the database (if
CacheStore configured)• Features:
• Can be optionally used with CacheStore to update the database.• Database will not be up to date until Coherence flushes changes
through CacheStore• Will not benefit from EclipseLink performance features such as batch
writing
Grid Entity—Reading Objects (Same as Grid Read)
1. Queries are performed using JPA em.find(..) or JPQL.
2. JQPL will be translated to a Coherence Filter and used to query results from Coherence. A find() will result in a get() on the result in a get() on the appropriate Coherence cache.
• The database is not queried by EclipseLink.
• If Coherence is configured with a CacheLoader then a find() may result in a SELECT, but JQPL will not.
Grid Entity—Writing Objects
1. An application commits a transaction with new Entities or modifications to existing Entities.
2. EclipseLink put()s all new and updated Entities into Coherence.Coherence.
3. If a CacheStore is configured, Coherence will synchronously or asynchronously write the changes to the database, depending on configuration.
Demonstrations
Toplink Grid for Scaling out JPA
Oracle&SunOracle&Sun
Java RuntimeJava SE
• Rapidly deliver Java SE 7 with many new features• Modularization• Developer productivity• Multiple languages• Higher performance• Support for Multi-Core Processors
• HotSpot and JRockit are strategic JVMs• HotSpot and JRockit are strategic JVMs• Converge best features of HotSpot and JRockit• Management and Real-time Monitoring• Run natively on Hypervisors • Optimize/Remove Permgen• Thread Local, Server Class Garbage Collection• NUMA Compiler Optimization for Multi-Cores
• Continued support for all leading OSs
Java Application ServerJava EE
• Evolve current Java EE RI to further address key initiatives• Modularity with Open Standards• New Lightweight Server Profiles• UI and Rich Internet Applications
• Glassfish and WebLogic are • Glassfish and WebLogic are strategic Application Servers• Glassfish remains Java EE
Reference Implementation• WebLogic remains strategic
Enterprise Application Server
• No change in support timelines or distribution model for Glassfish