In-Memory Datagrid Computing mit Oracle Coherence

<Insert Picture Here>
In-Memory Datagrid Computing mit Oracle Coherence
Michael Bräuer
Oracle Deutschland B.V. & Co KG
The following is intended to outline our general
product direction. It is intended for information
purposes only, and may not be incorporated into any
contract. It is not a commitment to deliver any
material, code, or functionality, and should not be
relied upon in making purchasing decisions.
The development, release, and timing of any
features or functionality described for Oracle’s
products remains at the sole discretion of Oracle.
Agenda
• Motivation
• In-Memory Data Grids
• Einführung in Oracle Coherence
– Konfiguration und Administration
– Entwicklung
• Ein Blick auf das Java API
• Integration mit Datenbanken
• Fragen und Antworten
<Insert Picture Here>
Motivation
Über die Zeit: Wir haben da ein Problem …
• Was dann oft schon gemacht wurde:
–
–
–
–
–
Upgrade auf aktuellste Softwarekomponenten
Einsatz der aktuellsten Sprach-Features
Einsatz optimaler Datenstrukturen und Algorithmen
Hardware ist State-of-the-Art
Tuning erfolgt regelmäßig
• Wo ist das Problem?
– Frage nach Kapazität, Latenz, (verteiltem Zugriff)
– Analogie: Warteschlange am Flughafenschalter
• Benutzer der bedient wird: ―fühlt‖ gute Performanz
• Benutzer in Warteschlange ―erfahren‖ weniger gute
Performanz
<Insert Picture Here>
In-Memory Datagrid
Definition In-Memory Datagrid
• Ein In-Memory Datgrid ist ein [In-Memory]
Datenmanagment-System zum Verwalten von
Anwendungsobjekten, welche verteilt genutzt
werden können.
Es zeichnet sich durch
–
–
–
–
–
eine geringe Latenz bei Zugriffen
einen hohen Durchsatz
vorhersehbare Skalierbarkeit
hohe Verfügbarkeit und
ein robustes Verhalten
aus.
In-Memory Datagrid
• Kein Allheilmittel
• ABER: wird oft unterschätzt:
– Brauchen wir nicht
– Baue ich mal schnell selber
–…
• Deshalb: bei jeder Architekturbetrachtung in
Diskussion einbeziehen
<Insert Picture Here>
Einführung in Oracle
Coherence
Was ist Oracle Coherence?
• Eine Java Bibliothek:
• ~ 12 MB Download: coherence-java-3.7.0.0b23397.zip
• keine Abhängigkeit zu anderen Bibliotheken,
ausser JDK (>= 1.5)
• Java, .NET, C++ Client API
(für .NET und C++ zusätzliche Bibliotheken zum
Download)
• Coherence Knoten ist JVM Prozess,
gestartet mit notwendigen Coherence Java Bibliothek und
Konfigurationsdateien
• Storageknoten können Daten aufnehmen/verwalten,
spezielle Serialisierungsmechanismen sind möglich
• Coherence Knoten laufen in Coherence Cluster:
dynamische Kapazität, spezielle Protokolle (TCMP)
Was ist Oracle Coherence?
• Client (Java, .NET, C++) verbindet sich mit Cluster
(wird selbst Teil des Verbunds) und iniitiert CRUD
Operationen, Berechnungen, Abfragen
Dynamisches
Hinzufügen/Wegnehmen
von Knoten
Coherence Cluster Consensus
• Coherence Consensus basiert auf
– speziellem Network Stack: TCMP
– TCMP = The Consensus Management Protocol ;-)
– TCMP = Tangosol Coherence Management Protocol
• TCMP
– Vollständig asynchron, feste Anzahl von Sockets (2+1) und
Threads pro JVM (6+1) – unabhängig von Clustergrösse 
– Server Discovery, Cluster Management, Service Provisioning
Data Transmission
Begrifflichkeiten
• Service:
– Menge von Threads für dedizierte Aufgabe
– Verschiedene Typen, z.B. Connectivity Services,
Processing Services, Cache Services
• Cluster: Menge von Services innerhalb eines
definierten Verbundes im Netzwerk
• Cache:
– bildet Schlüssel auf Werte ab
– wird mittels Namen referenziert(deshalb interface
NamedCache.)
– typischerweise geclustert, d.h. Zugriff von jedem
Clustermitglied aus
Begrifflichkeiten
• Backing Map:
– Datenstruktur eines Storage-Knotens zum Verwalten des
Inhalts von Caches
Cache Typen – Replicated Cache
• Jeder Knoten hat alle Informationen: für
Lesezugreiffe perfekt, aber …
Cache Typen – Replicated Cache
• Jeder Knoten hat alle Informationen: schreiben
aufwendig und Größe limitiert durch Heap Size
Cache Typen – Partitioned Cache
• = ―distributed cache‖: partitioniert, Load-Balancing,
Lokationstransparenz, Failover
Cache Typen – Partitioned Cache
• = ―distributed cache‖: partitioniert, Load-Balancing,
Lokationstransparenz, Failover
Cache Typen – Partitioned Cache
• = ―distributed cache‖: partitioniert, Load-Balancing,
Lokationstransparenz, Failover
Cache Typen – Partitioned Cache
• = ―distributed cache‖: partitioniert, Load-Balancing,
Lokationstransparenz, Failover
Cache Typen – Local Cache
• Jeder Knoten hat nur Informationen lokal
• Keine geclusterten Services
• Implementiert gleiche Standard Collections wie
geclusterte Caches
• Wird in Kombination mit geclusterten Services
benutzt
Cache Typen – Near Cache
• Kombiniert Local Cache mit Distributed Cache
Cache Konfiguration
• Coherence benutzt XML File zur Konfiguration der
Cache Topologie
• Zwei Abschnitte
– Cache Names mit Mapping auf Cache Schemes
– Definition der Cache Schemes
• Beim Aufruf von CacheFactory.getCache("name") wird
Argument mit Namen im Konfigurationsfile
verglichen
Cache Konfiguration
• coherence.jar beinhaltet coherence-cache-config.xml
• Überschreiben mittels:
– -Dtangosol.coherence.cacheconfig=my-config.xml
– Oder in coherence-tangosol-override*.xml
Cluster Konfiguration
• coherence.jar beinhaltet coherence-tangosol*.xml
• Überschreiben von Parametern mittels:
– Java System Properties
– coherence-tangosol-override*.xml im Classpath vor
coherence.jar oder mittels -Dtangosol.coherence.override
• Beispiel: Benutzung von WKAs (Well Known
Adresses) anstelle von Multicast
Exkurs Serialisierung – Portable Object
Format
• Vergleich
– XML
• <date format=―java.util.Date‖>2008-07-03</date>
• 47 Zeichen (möglich 94 bytes abhängig vom Encoding)
– Java (raw long)
• 64 bits = 8 bytes
– Java (java.util.Date mit ObjectOutputStream)
• 46 bytes
– In ExternalizableLite (raw long)
• 8 bytes
– In POF (portierbares, effizientes Format)
• 4F 58 1F 70 6C = 5 bytes
Exkurs Serialisierung – Portable Object
Format
• Eigener Pof Serializer oder Interface
com.tangosol.io.pof.PortableObject implementieren:
Management
• Management basiert vollständig auf JMX
• Z.B. Verbindung mit JConsole o.ä.
• Dedizierte Knoten, z.B. mit System Properties
– -Dcom.sun.management.jmxremote
– -Dtangosol.coherence.management=all
– -Dtangosol.coherence.management.remote=true
• Management Knoten sind Teil des Clusters, deshalb:
– -Dtangosol.coherence.distributed.localstorage= false
• Gute Integration in Oracle Management Produkte
(Enterprise Manager) und Drittparteilösungen
• Sehr gute Integration in Oracle GlassFish Server und
Oracle WebLogic Server !
<Insert Picture Here>
Ein Blick auf das API
Clustering Java Prozesse
• Cluster beitreten oder
neuen Cluster formieren
• cluster enthält
Information über
–
–
–
–
Cluster Name
Members
Locations
Processes
• Es gibt keinen ―Master
Server‖
• Es gibt keine ―Server
Registries‖
Cluster cluster = CacheFactory.ensureCluster();
Einen Cluster verlassen
• Verlässt den aktuellen
Cluster
• shutdown blockt bis
Daten ―sicher‖
CacheFactory.shutdown();
Benutzen des Caches
get, put, size & remove
• CacheFactory löst
Cache Namen auf (z.B:
“mine”) wurde als Cache
konfiguriert
NamedCache nc = CacheFactory.getCache(“mine”);
Object previous = nc.put(“key”, “hello world”);
Object current = nc.get(“key”);
• NamedCache liefert
Topologie-agnostischen
Zugriff auf Information
• NamedCache
Implementierungen
implementieren
verschiedene Interfaces:
– java.util.Map, Jcache,
ObservableMap*,
ConcurrentMap*,
QueryMap*,
InvocableMap*
int size = nc.size();
Object value = nc.remove(“key”);
Coherence* Extensions
Benutzen des Caches
keySet, entrySet, containsKey
• Benutzung eines
NamedCache ist analog
zu java.util.Map
NamedCache nc = CacheFactory.getCache(“mine”);
• Was ist gleich/anders?
Set entries = nc.entrySet();
– Beide nutzen (key,value)
Paare für Einträge
– Map Einträge haben kein
Ablauf (Expiration)
– Maps sind limitiert durch
Heap Space
– Caches sind
typischerweise grössenlimitiert (#Einträge oder
Speicher)
– Map ist In-Process
Set keys = nc.keySet();
boolean exists = nc.containsKey(“key”);
Querying Caches
QueryMap
• Abfragen über
NamedCache (Data Grid):
–
–
Parallele Abfragen
mit Filter
• Ergebnisse können
geordnet werden:
–
–
natürliche Ordnung
Comparators
• Filter liefern umfangreiche
Funktionalität ala SQL
Where Klausel
• Eigene Filter
NamedCache nc = CacheFactory.getCache(“people”);
Set keys = nc.keySet(
new LikeFilter(“getLastName”,
“%Stone%”));
Set entries = nc.entrySet(
new EqualsFilter(“getAge”,
35));
Überwachen von Veränderungen
ObservableMap
• Überwachungen von
Veränderungen in
Echtzeit
NamedCache nc = CacheFactory.getCache(“stocks”);
nc.addMapListener(new MapListener() {
public void onInsert(MapEvent mapEvent) {
}
• Optionen: Benutzung
von Filtern und Lite
Events
• Verschiedene
MapListener stehen
zur Verfügung:
– Abstract, Multiplexing...
public void onUpdate(MapEvent mapEvent) {
}
public void onDelete(MapEvent mapEvent) {
}
});
Aggregieren von Information
InvocableMap
• Aggregierte Werte eines
NamedCache im gesamten
Cluster (Data Grid):
–
–
Parallele Aggregation
mit Filter
• Aggregationskonstrukte
beinhalten:
–
Distinct, Sum, Min, Max,
Average, Having, Group By
• Eigene Aggregate
NamedCache nc = CacheFactory.getCache(“stocks”);
Double total = (Double)nc.aggregate(
AlwaysFilter.INSTANCE,
new DoubleSum(“getQuantity”));
Set symbols = (Set)nc.aggregate(
new EqualsFilter(“getOwner”, “Larry”),
new DistinctValue(“getSymbol”));
Update von Cache Einträgen
InvocableMap
• Aufruf von
EntryProcessor auf
einem oder mehreren
Einträgen eines
NamedCache im Cluster
(Data Grid):
–
NamedCache nc = CacheFactory.getCache(“stocks”);
nc.invokeAll(
new EqualsFilter(“getSymbol”, “ORCL”),
new StockSplitProcessor());
parallel (mit Filter)
• Ausführung erfolgt dort, wo
sich Einträge befinden,
nicht im aufrufenden
Thread (Aufruf von
invoke)
...
class StockSplitProcessor extends
AbstractProcessor {
Object process(Entry entry) {
Stock stock = (Stock)entry.getValue();
stock.quantity *= 2;
entry.setValue(stock);
return null;
}
• erlaubt Daten +
Processing Affinität
}
Beispiel EntryProcessor: Gibt es Cache
Eintrag
…
NamedCache nc = CacheFactory.getCache(“entriesManipulated”);
Filter filter = new NotFilter(PresentFilter.INSTANCE);
Object result = cache.invoke(key, new ConditionalPut(filter, value,
true));
…
• Aufruf von EntryProcessor effizienter als explizites Locking
• Parallelität
• Serverseitiger Ablauf
<Insert Picture Here>
Integration mit
Datenbanken
Integration mit Datenbanken
• CacheLoader, CacheStore: read-through, refreshahead, write-through, write-behind
• TopLink Grid: Basis ist das JPA Programmiermodell
Read-Through
Write-Through
Write-Behind
Zusammenfassung
• Oracle Coherence realisiert In-Memory Datagrid, mit
– sehr geringe Latenzzeiten und einem hohen Durchsatz
– vorhersehbarer Skalierbarkeit für Lese- als auch
Schreibzugriff
– hoher Verfügbarkeit
– keine Single-Point-of-Failures (SPOF)
– schnellem transparentes Failover und Failback
– Zugriff auf In-Memory gehaltenen Daten (Objekte) durch
verschiedene Programmiersprachen, wie Java, .Net, und
C++
– ...
• Wertschöpfung in neuen und bestehenden
Architekturen
Fragen
Zusätzliche Information
• Coherence Tutorial (Coherence 3.7.1)
– http://docs.oracle.com/cd/E24290_01/coh.371/e22622/toc.ht
m
– http://docs.oracle.com/cd/E24290_01/coh.371/e22622.pdf
• Coherence Beispiele
– http://docs.oracle.com/cd/E24290_01/coh.371/examples.zip
• Downloads und Online Dokumentation (inkl. Java
Doc):
– http://www.oracle.com/technetwork/middleware/coherence/d
ownloads/index.html
– http://docs.oracle.com/cd/E24290_01/index.htm
<Insert Picture Here>
Exkurs TopLink Grid,
Coherence*Web
TopLink Grid
• Idea: use JPA programing model and Coherence
• Grid Cache—Coherence as Shared (L2) Cache
– Configurable per Entity type
– Entities read by one grid member are put into Coherence and
are immediately available across the entire grid
• Grid Read
– All supported read queries executed in the Coherence data
grid
– All writes performed directly on the database by TopLink
(synchronously) and Coherence updated
• Grid Entity
– All supported read queries and all writes are executed in the
Coherence data grid
Coherence*Web
What: Distributed HTTP Session Management
Span Applications: Seamlessly share sessions between
applications
Scale in Heterogeneous Environments: Manage sessions in
WebLogic, Glassfish, WebSphere, JBoss
Handle Large Sessions: Store more information within the
session
Coherence*Web
Why:
Decouple session management from web container
Handle more users without adding more application servers
Restart/maintain applications/containers without loosing
sessions
Handle very large sessions efficiently
Keep session data coherent under heavy load