Panduan untuk Apache Ignite

1. Pengenalan

Apache Ignite adalah platform diedarkan berpusatkan memori sumber terbuka. Kita dapat menggunakannya sebagai pangkalan data, sistem caching atau untuk pemprosesan data dalam memori.

Platform ini menggunakan memori sebagai lapisan penyimpanan, oleh itu mempunyai kadar prestasi yang mengagumkan. Ringkasnya, ini adalah salah satu platform pemprosesan data atom terpantas yang kini digunakan dalam pengeluaran.

2. Pemasangan dan Persediaan

Sebagai permulaan, periksa halaman permulaan untuk arahan persediaan dan pemasangan awal.

Pergantungan Maven untuk aplikasi yang akan kami bina:

 org.apache.ignite ignite-core ${ignite.version}   org.apache.ignite ignite-indexing ${ignite.version} 

ignite-core adalah satu-satunya kebergantungan wajib untuk projek ini . Oleh kerana kami juga mahu berinteraksi dengan SQL, ignite-indexing juga ada di sini. $ {ignite.version} adalah versi terbaru Apache Ignite.

Sebagai langkah terakhir, kita memulakan nod Ignite:

Ignite node started OK (id=53c77dea) Topology snapshot [ver=1, servers=1, clients=0, CPUs=4, offheap=1.2GB, heap=1.0GB] Data Regions Configured: ^-- default [initSize=256.0 MiB, maxSize=1.2 GiB, persistenceEnabled=false]

Output konsol di atas menunjukkan bahawa kami sudah bersedia untuk pergi.

3. Senibina Memori

Platform ini berdasarkan Senibina Memori Tahan Lama . Ini memungkinkan untuk menyimpan dan memproses data pada cakera dan memori. Ia meningkatkan prestasi dengan menggunakan sumber RAM kluster dengan berkesan.

Data dalam memori dan cakera mempunyai perwakilan binari yang sama. Ini bermaksud tiada penukaran data tambahan semasa bergerak dari satu lapisan ke lapisan lain.

Senibina memori tahan lama terbahagi kepada blok berukuran tetap yang disebut halaman. Halaman disimpan di luar timbunan Java dan disusun dalam RAM. Ia mempunyai pengecam unik: FullPageId .

Halaman berinteraksi dengan memori menggunakan abstraksi PageMemory .

Membantu membaca, menulis halaman, juga memperuntukkan id halaman. Di dalam memori, Ignite mengaitkan halaman dengan Memory Buffer .

4. Halaman Memori

Halaman boleh mempunyai keadaan berikut:

  • Tidak dimuat - tiada penyangga halaman dimuat dalam memori
  • Kosongkan - penyangga halaman dimuat dan diselaraskan dengan data pada cakera
  • Durty - penyangga halaman menyimpan data yang berbeza dari yang ada dalam cakera
  • Kotor di pusat pemeriksaan - ada pengubahsuaian lain bermula sebelum yang pertama berterusan ke cakera. Di sini titik pemeriksaan dimulakan dan PageMemory menyimpan dua penyangga memori untuk setiap Halaman.

Memori tahan lama memperuntukkan segmen memori tempatan yang disebut Wilayah Data . Secara lalai, ia mempunyai kapasiti 20% memori kluster. Konfigurasi pelbagai kawasan membolehkan menyimpan data yang dapat digunakan dalam memori.

Kapasiti maksimum wilayah adalah Segmen Memori. Ini adalah memori fizikal atau susunan bait berterusan.

Untuk mengelakkan pecahan memori, satu halaman menyimpan banyak entri nilai kunci . Setiap entri baru akan ditambahkan ke halaman yang paling optimum. Sekiranya ukuran pasangan kunci-nilai melebihi kapasiti maksimum halaman, Ignite menyimpan data di lebih dari satu halaman. Logik yang sama berlaku untuk mengemas kini data.

Indeks SQL dan cache disimpan dalam struktur yang dikenali sebagai B + Trees. Kekunci cache disusun mengikut nilai kunci mereka.

5. Kitaran hidup

Setiap nod Ignite berjalan pada satu contoh JVM . Walau bagaimanapun, mungkin untuk mengkonfigurasi agar beberapa nod Ignite berjalan dalam satu proses JVM.

Mari kita lihat jenis acara kitaran hidup:

  • BEFORE_NODE_START - sebelum permulaan nod Ignite
  • AFTER_NODE_START - kebakaran sejurus selepas nod Ignite bermula
  • BEFORE_NODE_STOP - sebelum memulakan node berhenti
  • AFTER_NODE_STOP - selepas simpul Ignite berhenti

Untuk memulakan nod Ignite lalai:

Ignite ignite = Ignition.start();

Atau dari fail konfigurasi:

Ignite ignite = Ignition.start("config/example-cache.xml");

Sekiranya kita memerlukan lebih banyak kawalan terhadap proses inisialisasi, ada cara lain dengan bantuan antara muka LifecycleBean :

public class CustomLifecycleBean implements LifecycleBean { @Override public void onLifecycleEvent(LifecycleEventType lifecycleEventType) throws IgniteException { if(lifecycleEventType == LifecycleEventType.AFTER_NODE_START) { // ... } } }

Di sini, kita dapat menggunakan jenis peristiwa kitaran hidup untuk melakukan tindakan sebelum atau selepas nod bermula / berhenti.

Untuk tujuan itu, kami meneruskan contoh konfigurasi dengan CustomLifecycleBean ke kaedah permulaan:

IgniteConfiguration configuration = new IgniteConfiguration(); configuration.setLifecycleBeans(new CustomLifecycleBean()); Ignite ignite = Ignition.start(configuration);

6. Grid Data Dalam Memori

Grid data Ignite adalah penyimpanan nilai kunci yang diedarkan , sangat biasa dengan HashMap yang dipisahkan . Ia berskala melintang. Ini bermaksud lebih banyak node kluster yang kita tambahkan, lebih banyak data disimpan dalam cache atau disimpan dalam memori.

Ia dapat memberikan peningkatan prestasi yang signifikan pada perisian pihak ketiga, seperti NoSql, pangkalan data RDMS sebagai lapisan tambahan untuk cache.

6.1. Sokongan Caching

API akses data berdasarkan spesifikasi JCache JSR 107.

Sebagai contoh, mari buat cache menggunakan konfigurasi templat:

IgniteCache cache = ignite.getOrCreateCache( "baeldingCache");

Mari lihat apa yang berlaku di sini untuk maklumat lebih lanjut. Pertama, Ignite mencari kawasan memori di mana cache disimpan.

Kemudian, Halaman indeks pokok B + akan diletakkan berdasarkan kod hash utama. Sekiranya indeks ada, Halaman data kunci yang sesuai akan berada.

Apabila indeks NULL, platform membuat kemasukan data baru dengan menggunakan kunci yang diberikan.

Seterusnya, mari tambah beberapa objek Pekerja :

cache.put(1, new Employee(1, "John", true)); cache.put(2, new Employee(2, "Anna", false)); cache.put(3, new Employee(3, "George", true));

Again, the durable memory will look for the memory region where the cache belongs. Based on the cache key, the index page will be located in a B+ tree structure.

When the index page doesn't exist, a new one is requested and added to the tree.

Next, a data page is assigning to the index page.

To read the employee from the cache, we just use the key value:

Employee employee = cache.get(1);

6.2. Streaming Support

In memory data streaming provides an alternative approach for the disk and file system based data processing applications. The Streaming API splits the high load data flow into multiple stages and routes them for processing.

We can modify our example and stream the data from the file. First, we define a data streamer:

IgniteDataStreamer streamer = ignite .dataStreamer(cache.getName());

Next, we can register a stream transformer to mark the received employees as employed:

streamer.receiver(StreamTransformer.from((e, arg) -> { Employee employee = e.getValue(); employee.setEmployed(true); e.setValue(employee); return employee; }));

As a final step, we iterate over the employees.txt file lines and convert them into Java objects:

Path path = Paths.get(IgniteStream.class.getResource("employees.txt") .toURI()); Gson gson = new Gson(); Files.lines(path) .forEach(l -> streamer.addData( employee.getId(), gson.fromJson(l, Employee.class)));

With the use of streamer.addData() put the employee objects into the stream.

7. SQL Support

The platform provides memory-centric, fault-tolerant SQL database.

We can connect either with pure SQL API or with JDBC. SQL syntax here is ANSI-99, so all the standard aggregation functions in the queries, DML, DDL language operations are supported.

7.1. JDBC

To get more practical, let's create a table of employees and add some data to it.

For that purpose, we register a JDBC driver and open a connection as a next step:

Class.forName("org.apache.ignite.IgniteJdbcThinDriver"); Connection conn = DriverManager.getConnection("jdbc:ignite:thin://127.0.0.1/");

With the help of the standard DDL command, we populate the Employee table:

sql.executeUpdate("CREATE TABLE Employee (" + " id LONG PRIMARY KEY, name VARCHAR, isEmployed tinyint(1)) " + " WITH \"template=replicated\"");

After the WITH keyword, we can set the cache configuration template. Here we use the REPLICATED. By default, the template mode is PARTITIONED. To specify the number of copies of the data we can also specify BACKUPS parameter here, which is 0 by default.

Then, let's add up some data by using INSERT DML statement:

PreparedStatement sql = conn.prepareStatement( "INSERT INTO Employee (id, name, isEmployed) VALUES (?, ?, ?)"); sql.setLong(1, 1); sql.setString(2, "James"); sql.setBoolean(3, true); sql.executeUpdate(); // add the rest 

Afterward, we select the records:

ResultSet rs = sql.executeQuery("SELECT e.name, e.isEmployed " + " FROM Employee e " + " WHERE e.isEmployed = TRUE ")

7.2. Query the Objects

It's also possible to perform a query over Java objects stored in the cache. Ignite treats Java object as a separate SQL record:

IgniteCache cache = ignite.cache("baeldungCache"); SqlFieldsQuery sql = new SqlFieldsQuery( "select name from Employee where isEmployed = 'true'"); QueryCursor
    
      cursor = cache.query(sql); for (List row : cursor) { // do something with the row }
    

8. Summary

In this tutorial, we had a quick look at Apache Ignite project. This guide highlights the advantages of the platform over other simial products such as performance gains, durability, lightweight APIs.

Hasilnya, kami belajar bagaimana menggunakan bahasa SQL dan Java API untuk menyimpan, mengambil, mengalirkan data di dalam grid ketekunan atau dalam memori.

Seperti biasa, kod lengkap untuk artikel ini terdapat di GitHub.