Een beknopte handleiding voor Apache Geode
1. Overzicht
Apache Geode is een gedistribueerd gegevensraster in het geheugen dat caching en gegevensberekening ondersteunt.
In deze tutorial behandelen we de belangrijkste concepten van Geode en nemen we enkele codevoorbeelden door met behulp van de Java-client.
2. Installatie
Eerst moeten we Apache Geode downloaden en installeren en de gfsh milieu. Om dit te doen, kunnen we de instructies volgen in de officiële gids van Geode.
En ten tweede zal deze tutorial enkele bestandssysteemartefacten creëren. We kunnen ze dus isoleren door een tijdelijke map te maken en vanaf daar dingen te starten.
2.1. Installatie en configuratie
Vanuit onze tijdelijke directory moeten we een Zoeker voorbeeld:
gfsh> start locator --naam = locator --bind-adres = localhostLocators zijn verantwoordelijk voor de coördinatie tussen verschillende leden van een Geode TROS, die we verder kunnen beheren via JMX.
Laten we vervolgens een Server instantie om een of meer gegevens te hosten Regios:
gfsh> start server --naam = server1 --server-poort = 0We stellen de -Server poort optie op 0 zodat Geode elke beschikbare poort kiest. Maar als we het weglaten, zal de server de standaardpoort 40404 gebruiken. Een server is een configureerbaar lid van de TROS dat verloopt als een langdurig proces en verantwoordelijk is voor het beheer van data Regio's.
En tot slot hebben we een Regio:
gfsh> maak regio --name = baeldung --type = REPLICATEDe Regio is uiteindelijk waar we onze gegevens zullen opslaan.
2.2. Verificatie
Laten we ervoor zorgen dat alles werkt voordat we verder gaan.
Laten we eerst eens kijken of we onze hebben Server en onze Zoeker:
gfsh> lijst leden Naam | Id ------- | -------------------------------------------------- -------- server1 | 192.168.0.105 (server1: 6119): 1024 locator | 127.0.0.1 (locator: 5996: locator): 1024 [Coördinator]En vervolgens hebben we onze Regio:
gfsh> beschrijf regio --naam = baeldung ......................................... ................. Naam: baeldung Gegevensbeleid: repliceren Hosting-leden: server1 Niet-standaardattributen gedeeld door hostende leden Type | Naam | Waarde ------ | ----------- | --------------- Regio | gegevensbeleid | REPLICATE | maat | 0 | bereik | gedistribueerd-ackWe zouden ook enkele mappen op het bestandssysteem moeten hebben onder onze tijdelijke map genaamd "locator" en "server1".
Met deze output weten we dat we klaar zijn om verder te gaan.
3. Maven Afhankelijkheid
Nu we een actieve Geode hebben, gaan we naar de clientcode kijken.
Om met Geode in onze Java-code te werken, moeten we de Apache Geode Java-clientbibliotheek toevoegen aan onze pom:
org.apache.geode geode-core 1.6.0 Laten we beginnen met het simpelweg opslaan en ophalen van enkele gegevens in een aantal regio's.
4. Eenvoudig opslaan en ophalen
Laten we laten zien hoe u enkele waarden, batches met waarden en aangepaste objecten opslaat.
Om te beginnen met het opslaan van gegevens in onze "baeldung" -regio, laten we er verbinding mee maken met behulp van de locator:
@Before public void connect () {this.cache = nieuwe ClientCacheFactory () .addPoolLocator ("localhost", 10334) .create (); this.region = cache. createClientRegionFactory (ClientRegionShortcut.CACHING_PROXY) .create ("baeldung"); }4.1. Enkele waarden opslaan
Nu kunnen we eenvoudig gegevens in onze regio opslaan en ophalen:
@Test openbare leegte whenSendMessageToRegion_thenMessageSavedSuccessfully () {this.region.put ("A", "Hallo"); this.region.put ("B", "Baeldung"); assertEquals ("Hallo", region.get ("A")); assertEquals ("Baeldung", region.get ("B")); }4.2. Meerdere waarden tegelijk opslaan
We kunnen ook meerdere waarden tegelijk opslaan, bijvoorbeeld wanneer we proberen de netwerklatentie te verminderen:
@Test public void whenPutMultipleValuesAtOnce_thenValuesSavedSuccessfully () {Leverancier keys = () -> Stream.of ("A", "B", "C", "D", "E"); Kaartwaarden = keys.get () .collect (Collectors.toMap (Function.identity (), String :: toLowerCase)); this.region.putAll (waarden); keys.get () .forEach (k -> assertEquals (k.toLowerCase (), this.region.get (k))); } 4.3. Aangepaste objecten opslaan
Tekenreeksen zijn handig, maar eerder dan later moeten we aangepaste objecten opslaan.
Laten we ons voorstellen dat we een klantrecord hebben dat we willen opslaan met het volgende sleuteltype:
public class CustomerKey implementeert Serializable {privé lange id; privé String land; // getters en setters // is gelijk aan en hashcode}En het volgende waardetype:
openbare klasse Klant implementeert serialiseerbare {privé CustomerKey-sleutel; private String voornaam; private String achternaam; privé Integer leeftijd; // getters en setters}Er zijn een aantal extra stappen om deze op te slaan:
Eerste, ze zouden moeten implementeren Serialiseerbaar. Hoewel dit geen strikte vereiste is, door ze te maken Serialiseerbaar, Geode kan ze robuuster opslaan.
Tweede, ze moeten zowel op het klassenpad van onze applicatie als op het klassenpad van onze Geode staan Server.
Om ze naar het klassenpad van de server te krijgen, gaan we ze verpakken, bijvoorbeeld met mvn schoon pakket.
En dan kunnen we naar de resulterende pot verwijzen in een nieuwe start server opdracht:
gfsh> stop server --naam = server1 gfsh> start server --naam = server1 --classpath = .. / lib / apache-geode-1.0-SNAPSHOT.jar --server-port = 0Nogmaals, we moeten deze opdrachten uitvoeren vanuit de tijdelijke map.
Laten we tot slot een nieuw Regio met de naam "baeldung-klanten" op de Server met hetzelfde commando dat we gebruikten voor het creëren van de "baeldung" -regio:
gfsh> maak regio --name = baeldung-klanten --type = REPLICATEIn de code nemen we contact op met de locator zoals eerder, waarbij we het aangepaste type specificeren:
@Before public void connect () {// ... maak verbinding via de locator this.customerRegion = this.cache. createClientRegionFactory (ClientRegionShortcut.CACHING_PROXY) .create ("baeldung-klanten"); }En dan kunnen we onze klant opslaan zoals voorheen:
@Test openbare ongeldig wanneerPutCustomKey_thenValuesSavedSuccessfully () {CustomerKey-sleutel = nieuwe CustomerKey (123); Klant klant = nieuwe klant (sleutel, "William", "Russell", 35); this.customerRegion.put (sleutel, klant); Klant opgeslagenCustomer = this.customerRegion.get (sleutel); assertEquals ("William", opgeslagenCustomer.getFirstName ()); assertEquals ("Russell", opgeslagenCustomer.getLastName ()); }5. Regiotypes
Voor de meeste omgevingen hebben we meer dan één kopie of meer dan één partitie van onze regio, afhankelijk van onze lees- en schrijfverwerkingsvereisten.
Tot nu toe hebben we in het geheugen gerepliceerde regio's gebruikt. Laten we dat eens van dichterbij bekijken.
5.1. Gerepliceerde regio
Zoals de naam al doet vermoeden, een Gerepliceerde regio bewaart kopieën van zijn gegevens op meer dan één Server. Laten we dit testen.
Van de gfsh console in de werkmap, laten we er nog een toevoegen Server genaamd server2 naar het cluster:
gfsh> start server --naam = server2 --classpath = .. / lib / apache-geode-1.0-SNAPSHOT.jar --server-port = 0Onthoud dat toen we "baeldung" maakten, we gebruikten –Type = REPLICATE. Door dit, Geode zal onze gegevens automatisch naar de nieuwe server repliceren.
Laten we dit verifiëren door te stoppen server1:
gfsh> stop server --naam = server1En laten we dan een snelle zoekopdracht uitvoeren op de "baeldung" -regio.
Als de gegevens met succes zijn gerepliceerd, krijgen we resultaten terug:
gfsh> query --query = 'select e.key from /baeldung.entries e' Resultaat: true Limiet: 100 Rijen: 5 Resultaat ------ C B A E DDus het lijkt erop dat de replicatie is geslaagd!
Het toevoegen van een replica aan onze regio verbetert de beschikbaarheid van gegevens. En omdat meer dan één server op vragen kan reageren, krijgen we ook een hogere leesdoorvoer.
Maar, wat als ze allebei crashen? Aangezien dit in-memory regio's zijn, gaan de data verloren.Hiervoor kunnen we in plaats daarvan gebruiken –Type = REPLICATE_PERSISTENT die ook de gegevens op schijf opslaat tijdens het repliceren.
5.2. Gepartitioneerde regio
Met grotere datasets kunnen we het systeem beter schalen door Geode te configureren om een regio op te splitsen in afzonderlijke partities of buckets.
Laten we er een maken die is gepartitioneerd Regio genaamd "baeldung-partitioned":
gfsh> maak regio --name = baeldung-partitioned --type = PARTITIONVoeg wat gegevens toe:
gfsh> put --region = baeldung-partitioned --key = "1" --value = "één" gfsh> put --region = baeldung-partitioned --key = "2" --value = "twee" gfsh> put --region = baeldung-partitioned --key = "3" --value = "drie"En verifieer snel:
gfsh> query --query = 'selecteer e.key, e.value uit /baeldung-partitioned.entries e' Resultaat: waar Limiet: 100 Rijen: 3 sleutel | waarde --- | ----- 2 | twee 1 | een 3 | drieLaten we vervolgens stoppen om te valideren dat de gegevens zijn gepartitioneerd server1 opnieuw en vraag opnieuw:
gfsh> stop server --name = server1 gfsh> query --query = 'selecteer e.key, e.value uit /baeldung-partitioned.entries e' Resultaat: waar Limiet: 100 rijen: 1 sleutel | waarde --- | ----- 2 | tweeWe hebben deze keer slechts een deel van de gegevensinvoer teruggekregen omdat die server maar één partitie van de gegevens heeft, dus wanneer server1 is gevallen, zijn de gegevens verloren gegaan.
Maar wat als we zowel partitionering als redundantie nodig hebben? Geode ondersteunt ook een aantal andere typen. De volgende drie zijn handig:
- PARTITION_REDUNDANT partities en repliceert onze gegevens over verschillende leden van het cluster
- PARTITION_PERSISTENT verdeelt de gegevens zoals PARTITIE, maar naar schijf, en
- PARTITION_REDUNDANT_PERSISTENT geeft ons alle drie gedragingen.
6. Taal voor objectzoekopdrachten
Geode ondersteunt ook Object Query Language of OQL, wat krachtiger kan zijn dan het eenvoudig opzoeken van een sleutel. Het lijkt een beetje op SQL.
Laten we voor dit voorbeeld de "baeldung-klant" -regio gebruiken die we eerder hebben gebouwd.
Als we nog een paar klanten toevoegen:
Kaartgegevens = nieuwe HashMap (); data.put (nieuwe CustomerKey (1), nieuwe klant ("Gheorge", "Manuc", 36)); data.put (nieuwe CustomerKey (2), nieuwe Customer ("Allan", "McDowell", 43)); this.customerRegion.putAll (gegevens);Dan kunnen we gebruiken QueryService om klanten te vinden met de voornaam 'Allan':
QueryService queryService = this.cache.getQueryService (); String query = "selecteer * uit / baeldung-klanten c waar c.firstName = 'Allan'"; SelectResults-resultaten = (SelectResults) queryService.newQuery (query) .execute (); assertEquals (1, results.size ());7. Functie
Een van de krachtigere begrippen van gegevensrasters in het geheugen is het idee van "de berekeningen naar de gegevens".
Simpel gezegd, aangezien Geode pure Java is, het is voor ons gemakkelijk om niet alleen gegevens te verzenden, maar ook logica om op die gegevens uit te voeren.
Dit doet ons misschien denken aan het idee van SQL-extensies zoals PL-SQL of Transact-SQL.
7.1. Een functie definiëren
Om een werkeenheid voor Geode te definiëren,we implementeren Geode's Functie koppel.
Laten we ons bijvoorbeeld voorstellen dat we alle namen van de klant moeten veranderen in hoofdletters.
In plaats van de gegevens op te vragen en onze applicatie het werk te laten doen, kunnen we gewoon implementeren Functie:
openbare klasse UpperCaseNames implementeert Functie {@Override openbare leegte uitvoeren (FunctionContext-context) {RegionFunctionContext regionContext = (RegionFunctionContext) context; Regio regio = regionContext.getDataSet (); voor (Map.Entry entry: region.entrySet ()) {Customer customer = entry.getValue (); customer.setFirstName (customer.getFirstName (). toUpperCase ()); } context.getResultSender (). lastResult (true); } @Override public String getId () {return getClass (). GetName (); }}Let daar op getId moet een unieke waarde retourneren, dus de klassenaam is doorgaans een goede keuze.
De Functiecontext bevat al onze regiodata, en dus kunnen we er een meer verfijnde zoekopdracht uit doen, of, zoals we hier hebben gedaan, deze muteren.
En Functie heeft veel meer vermogen dan dit, dus bekijk de officiële handleiding, vooral de getResultSender methode.
7.2. Functie inzetten
We moeten Geode bewust maken van onze functie om deze te kunnen uitvoeren. Zoals we deden met onze aangepaste gegevenstypen, verpakken we de pot.
Maar deze keer kunnen we gewoon de inzetten opdracht:
gfsh> deploy --jar =. / lib / apache-geode-1.0-SNAPSHOT.jar7.3. Functie uitvoeren
Nu kunnen we het Functie vanuit de applicatie met behulp van de Functie Service:
@Test openbare ongeldigheid whenExecuteUppercaseNames_thenCustomerNamesAreUppercased () {Uitvoering uitvoering = FunctionService.onRegion (this.customerRegion); executie.execute (UpperCaseNames.class.getName ()); Klant klant = this.customerRegion.get (nieuwe CustomerKey (1)); assertEquals ("GHEORGE", customer.getFirstName ()); }8. Conclusie
In dit artikel hebben we de basisconcepten van de Apache Geode ecosysteem. We hebben gekeken naar eenvoudige get en putten met standaard en aangepaste typen, gerepliceerde en gepartitioneerde regio's, en oql en functieondersteuning.
En zoals altijd zijn al deze voorbeelden beschikbaar op GitHub.
