Java >> Java opplæring >  >> Tag >> native

Apache Ignite Native persistens, en kort oversikt

native

Tilnærminger i minnet kan oppnå lynraskt hastighet ved å sette arbeidssettet med data inn i systemminnet. Når alle data er lagret i minnet, forsvinner behovet for å håndtere problemer som oppstår ved bruk av tradisjonelle spinnende disker. Dette betyr for eksempel at det ikke er behov for å opprettholde flere cache-kopier av data og administrere synkronisering mellom dem. Men det er også en ulempe ved denne tilnærmingen fordi dataene kun er i minnet, de vil ikke overleve hvis hele klyngen blir avsluttet. Derfor regnes ikke denne typen datalagre som utholdenhet i det hele tatt.

I dette blogginnlegget vil jeg gjøre et forsøk på å utforske Apache Ignites nye native persistence-funksjon og gi et klart, forståelig bilde av hvordan Apache Ignite native persistence fungerer.

I de fleste tilfeller kan du ikke (bør ikke) lagre hele datasettet i minnet for applikasjonen din, oftest bør du lagre relativt små varme eller aktive undergrupper av data for å øke ytelsen til applikasjonen. Resten av dataene bør lagres et sted på rimelige disker eller tape for arkivering. Det er to hovedkrav til databaselagring i minnet tilgjengelig:

  • Permanent media, for å lagre forpliktede transaksjoner, og dermed opprettholde holdbarhet og for gjenopprettingsformål hvis minnedatabasen må lastes inn i minnet på nytt.
  • Permanent lagring, for å holde en sikkerhetskopi av hele databasen i minnet.

Permanent lagring eller media kan være et hvilket som helst distribuert eller lokalt filsystem, SAN, NoSQL-database eller til og med RDBMS som Postgres eller Oracle. Apache Ignite (siden 1.5) gir en elegant måte å koble sammen bestandighetsdatalagre som RDBMS eller NoSQL DB som Mongo DB eller Cassandra. Oftest vil utholdenhet i et RDBMS være flaskehalser, og du har aldri fått en horisontal skalering i systemet ditt. For mer informasjon anbefalte jeg deg å ta en titt på eksempelkapittelet i boken «Høy ytelse i minnet med Apache Ignite «.

Så fra  versjon 2.1.0 , tilbyr Apache Ignite ACID- og SQL-kompatibel disklager som transparent integreres med Ignites holdbare minne som et valgfritt disklag som lagrer data og indekser på SSD, Flash, 3D XPoint og andre typer ikke-flyktige lagringer.

Apache Ignite native persistence bruker ny  holdbar minnearkitektur som gjør det mulig å lagre og behandle data og indekser både i minnet og på disken. Når funksjonen aktiveres, lagrer Apache Ignite et supersett med data på disken og et undersett av data i RAM basert på kapasiteten. Hvis et undersett av data eller en indeks mangler i RAM, vil det holdbare minnet ta det fra disken som vist nye bilder nedenfor.

Data kan også lagres i det sentrale disklageret der alle Ignite-nodene er koblet til som vist nedenfor.

Før vi starter, la oss dekke forutsetningene til prosjektet i sandkassen vår:

  1. Apache Ignite versjon 2.1.0
  2. JVM 1.8
  3. Apache Maven versjon>3.0.3
  4. *nix-basert operativsystem

Installasjon.

Det er i hovedsak to måter å bruke Apache Ignite på:

  • Last ned den binære distribusjonen og pakk ut arkivet et sted i operativsystemet ditt og kjør ./ignite.sh bash-skriptet med vårkonfigurasjonsfilene.
  • Opprett et maven-prosjekt med de nødvendige Apache Ignite-avhengighetene, konfigurer noden gjennom java-koden og kjør den.

Her skal jeg bruke det første alternativet.

Trinn 1.

  • Last ned Apache Ignite-binærdistribusjonen og pakk ut distribusjonen et sted i sandkassen.
  • Endre IGNITE_HOME/examples/config/persistentstore/example-persistent-store.xml-filen og kommenter følgende del av hurtigbufferkonfigurasjonen.
<property name="cacheConfiguration">
<list>
    <bean class="org.apache.ignite.configuration.CacheConfiguration">
        <property name="name" value="testCache"/>
            <property name="backups" value="1"/>
            <property name="atomicityMode" value="TRANSACTIONAL"/>
            <property name="writeSynchronizationMode" value="FULL_SYNC"/>
            <property name="indexedTypes">
            <list>
            <value>java.lang.Long</value>
                <value>org.apache.ignite.examples.model.Organization</value>
            </list>
            </property>
        </bean>
    </list>
</property>

Merk at for å aktivere Ignite native persistence, trenger du bare å passere følgende konfigurasjon (en forekomst av PersistentStoreConfiguration), som allerede er forhåndskonfigurert i eksempel-persistent-store.XML-filen.

<property name="persistentStoreConfiguration">
<bean class="org.apache.ignite.configuration.PersistentStoreConfiguration"/>
</property>
  • Kjør følgende kommando fra IGNITE_HOME-katalogen.
./ignite.sh $IGNITE_HOME/examples/config/persistentstore/example-persistent-store.xml
Step 2. create a Maven project with the following command.
mvn archetype:create -DgroupId=com.blu.imdg -DartifactId=ignite-persistence
  • Legg til følgende avhengigheter i pom.xml
<dependency>
      <groupId>org.apache.ignite</groupId>
      <artifactId>ignite-core</artifactId>
      <version>2.1.0</version>
    </dependency>
    <dependency>
      <groupId>org.apache.ignite</groupId>
      <artifactId>ignite-spring</artifactId>
      <version>2.1.0</version>
    </dependency>
    <dependency>
      <groupId>org.apache.ignite</groupId>
      <artifactId>ignite-indexing</artifactId>
      <version>2.1.0</version>
    </dependency>
  • Opprett en Java-klasse med følgende innhold.
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello Ignite");
        // create a new instance of TCP Discovery SPI
        TcpDiscoverySpi spi = new TcpDiscoverySpi();
        // create a new instance of tcp discovery multicast ip finder
        TcpDiscoveryMulticastIpFinder tcMp = new TcpDiscoveryMulticastIpFinder();
        tcMp.setAddresses(Arrays.asList("localhost")); // change your IP address here
        // set the multi cast ip finder for spi
        spi.setIpFinder(tcMp);
        // create new ignite configuration
        IgniteConfiguration cfg = new IgniteConfiguration();
        cfg.setClientMode(true);
        // set the discovery§ spi to ignite configuration
        cfg.setDiscoverySpi(spi);
        // Start ignite
        Ignite ignite = Ignition.start(cfg);
        ignite.active(true);
        // get or create cache
        IgniteCache cache = ignite.getOrCreateCache("testCache");
        // put some cache elements
        for (int i = 1; i <= 100; i++) {
            cache.put(i, Integer.toString(i));
        }
        // get them from the cache and write to the console
        for (int i = 1; i <= 100; i++) {
            System.out.println("Cache get:" + cache.get(i));
        }
        ignite.close();

    }
}

Merk at vi bruker Ignite-klientmodus for å manipulere data. Etter å ha kjørt HelloWorld-applikasjonen skal 100 elementer settes inn i cachen (cachenavn
testCache ).

Trinn 3.

  • la oss bruke ignitevisor kommandoverktøyet til å undersøke dataene. bruk cache -scan-kommandoen i ignitevisor kommandoverktøyet. Du bør få den lignende illustrasjonen i konsollen din. Alle 100 elementene i cachen.
    • Nå, la oss se hva som skjedde under panseret. Kjør følgende kommando fra IGNITE_HOME/arbeidskatalogen
du -h .

Du bør få noe lignende i konsollen som vist nedenfor.

Hvis Apache Ignite native persistence aktiverer, vil Ignite bestå alle dataene og indeksen i minnet og på disken på tvers av alle klyngenodene.

Hvis du går gjennom katalogen db/0_0_0_0_0_0_0_1_10_211_55_2_10_37_129_2_127_0_0_1_192_168_1_37_47500 (i mitt tilfelle), finner du individuell mappe for hver cache. Mappen med navnet cache-testCache vil inneholde alle cache-oppføringene (100 elementer) som vi nettopp har satt inn.

Filen index.bin er indeksen til cache-oppføringene og hvert cache-element får sin individuelle sidefil. Hvorfor skjedde dette? nå er Ignite-arkitektur sidebasert arkitektur. La oss ta en nærmere titt, minnet deler seg nå inn i regioner -> regioner delt inn i segmenter -> segmenter delt inn i sider. Sider kan byttes inn på disken. Sider kan lagre:

  • data
  • metadata
  • indeks

Siden er blokk med fast lengde, den støtter også automatisk defragmentering. Hvis du ser nærmere på sidestørrelsen, er alle 14 KB. Når Ignite trenger å laste inn data fra disken, laster den bare sidefilen, og det er veldig raskt.

Det er også et annet konsept over skrive-forut-logg (WAL). Hvis du foretar en oppdatering, vil den først oppdatere dataene i minnet og merke siden som skitten, og deretter vil den bestå dataene i skrive-forut-loggen. Ignite bare legg til oppdateringen i WAL-filen. WAL-filen er veldig lik Cassandra-commitlog-filen, med én forskjell. Cassandra skriver parallelt inn i minnet og commitlog-filen på disken, på den annen side, Ignite oppdaterer dataene inn i minnet først og legger deretter til dataene i WAL. For mer informasjon anbefaler jeg at du tar en titt på
dokumentasjonen, som er ganske uttømmende.

Trinn 4.

  • Start Ignite-noden på nytt, og sjekk hurtigbufferen
    testCache med
    ignitevisor . Du vil ende opp med en overraskelse at ingen data i cachen.
  • La oss endre litt på helloworld-klassen vår og kjøre appen på nytt, kommentere eller slette følgende fragmenter av koden som vist nedenfor.
// put some cache elements
for (int i = 1; i <= 100; i++) {
  cache.put(i, Integer.toString(i));
}
Run the application and check the cache testCache through ignitevisor and you application console.

Når en leseforespørsel oppstår, kontrollerer Ignite først dataene i minnet. Hvis datasettet ikke finnes i minnet, laster Ignite umiddelbart cache-oppføringene fra disken og laster inn i minnet. Vær også oppmerksom på at alle oppføringer i minnet i offheap.

Fordeler .

Med Ignite native persistence kan du nå enkelt ta sikkerhetskopi for datagjenoppretting. Denis Magda skriver en omfattende artikkel for datagjenoppretting ved å bruke Ignite native persistence. En ting jeg må nevne her er datareplikeringen mellom klynger. Ved å bruke Ignite native persistence kan du nå replikere data fra en klynge til en annen på nettet. Du kan bruke alle standard diskbaserte datareplikeringsverktøy for å kopiere det endrede datasettet fra det primære datasenteret til stand-in datasenteret eller Ignite-klyngen.

Java Tag