Apa itu Space-Based Architecture dalam Arsitektur Perangkat Lunak? (+ Implementasi Program)

Assalamu‘alaikum wr. wb.

Halo gais! Dalam Arsitektur Perangkat Lunak, kita telah membahas tentang Event-Driven Architecture pada pembahasan sebelumnya. Sekarang, kita akan membahas tentang apa itu Space-Based Architecture. Mari kita bahas pada Artikel ini sampai tuntas.

Ilustrasi Space-Based Architecture

Sumber Materi : Oreilly.com, Dev.to (alexr), dan Slideshare.net (PPT)

Sebagian besar aplikasi bisnis berbasis web mengikuti alur permintaan umum yang sama. Permintaan dari browser masuk ke server web, lalu server aplikasi, lalu server basis data. Pola ini bekerja dengan baik untuk sekelompok kecil pengguna, tetapi saat beban pengguna meningkat, kemacetan terjadi pertama kali di tingkat server web, kemudian di tingkat server aplikasi, dan terakhir di tingkat server basis data.

Tanggapan yang biasa terhadap kemacetan karena peningkatan beban pengguna adalah dengan menskalakan server web. Ini relatif mudah dan murah, dan dapat membantu mengatasi masalah kemacetan. Namun, dalam sebagian besar kasus yang padat pengguna, menskalakan tingkat server web hanya memindahkan kemacetan ke server aplikasi. Penskalaan server aplikasi bisa lebih kompleks dan mahal daripada server web dan biasanya hanya memindahkan hambatan ke server basis data, yang bahkan lebih sulit dan mahal untuk diskalakan. Meskipun Anda dapat menskalakan basis data, Anda akan berakhir dengan topologi segitiga, dengan bagian segitiga yang lebih besar menjadi server web (yang paling mudah untuk diskalakan) dan bagian segitiga yang lebih besar. lebih kecil dari basis data (paling sulit untuk diskalakan).

Dalam aplikasi volume tinggi apa pun dengan beban pengguna bersamaan yang sangat besar, database biasanya akan menjadi faktor pembatas terakhir dalam berapa banyak transaksi yang dapat Anda proses secara bersamaan. Sementara berbagai teknologi caching dan produk penskalaan basis data membantu mengatasi masalah ini, faktanya tetap bahwa penskalaan aplikasi normal untuk beban ekstrem adalah proposisi yang sangat sulit.

Pola arsitektur berbasis ruang dirancang khusus untuk mengatasi dan memecahkan masalah skalabilitas dan konkurensi. Ini juga merupakan pola arsitektur yang berguna untuk aplikasi yang memiliki volume pengguna bersamaan yang bervariasi dan tidak dapat diprediksi. Memecahkan masalah skalabilitas ekstrim dan variabel secara arsitektural sering kali merupakan pendekatan yang lebih baik daripada mencoba memperluas skala basis data atau retrofit teknologi caching ke dalam arsitektur yang tidak dapat diskalakan.

A. Pengertian Space-Based Architecture

Space-Based Architecture (SBA) adalah pendekatan desain perangkat lunak yang mengatur sistem di sekitar konsep "ruang", yang pada dasarnya adalah unit fungsionalitas yang terisolasi dan otonom. Setiap ruang memiliki data, logika, dan antarmuka sendiri, dan mereka berkomunikasi satu sama lain melalui pengiriman pesan.

SBA didasarkan pada konsep arsitektur "shared nothing", di mana setiap node dalam klaster memiliki memori dan kekuatan pemrosesan sendiri, dan node tersebut berkomunikasi satu sama lain melalui pertukaran pesan. Hal ini memungkinkan arsitektur tersebut sangat scalable, fault-tolerant, dan mampu menangani volume data dan transaksi yang besar.

SBA umumnya digunakan dalam aplikasi yang memerlukan skalabilitas dan ketersediaan yang tinggi, seperti e-commerce, sistem perdagangan keuangan, dan analisis real-time. SBA juga digunakan dalam lingkungan komputasi awan, di mana ia menyediakan arsitektur yang sangat scalable dan elastis untuk menjalankan aplikasi terdistribusi. Contoh kerangka SBA termasuk Apache Geode, Apache Ignite, dan GigaSpaces.

B. Kelebihan dan Kekurangan dari Space-Based Architecture

Keuntungan dari Space-Based Architecture adalah :

Keuntungan utama menggunakan arsitektur berbasis ruang adalah bahwa hal itu mempromosikan isolasi dan otonomi tingkat tinggi, membuatnya lebih mudah untuk menguji, menerapkan, dan mengembangkan sistem. Karena setiap ruang bersifat independen, maka dapat dikembangkan, diuji, dan digunakan secara terpisah, memungkinkan pengembang untuk bekerja di ruang yang berbeda secara bersamaan. Selain itu, ini memungkinkan penanganan logika bisnis yang kompleks dengan mudah.

Keuntungan lain dari SBA adalah memungkinkan penanganan skalabilitas dan kinerja yang mudah. Karena setiap ruang diisolasi dan dapat diskalakan secara terpisah, ini memungkinkan kontrol yang lebih baik atas sumber daya yang digunakan oleh sistem.

Kekurangan dari Space-Based Architecture adalah :

Kerugian utama menggunakan SBA adalah dapat menambah kompleksitas pada sistem. Karena ruang-ruang tersebut independen, komunikasi di antara mereka dapat menjadi tantangan, dan memerlukan perencanaan dan koordinasi yang cermat. Selain itu, mungkin sulit untuk mendesain ruang dengan cara yang memastikan bahwa keduanya digabungkan secara longgar dan tidak berakhir dengan menciptakan ketergantungan di antara keduanya.

C. Jenis-jenis Komponen pada Space-Based Architecture

Space-Based Architecture Pattern

Pola Berbasis Ruang atau Space-Based Pattern (Terkadang juga disebut sebagai Pola Arsitektur Cloud) meminimalkan faktor yang membatasi penskalaan aplikasi. Skalabilitas tinggi dicapai dengan menghapus batasan database pusat dan menggunakan kisi data dalam memori yang direplikasi sebagai gantinya. Situs lelang penawaran adalah contoh yang bagus untuk ini, menerima tawaran dari pengguna internet melalui permintaan browser, memperbarui informasi penawaran untuk item tertentu, mencatat penawaran tersebut dengan stempel waktu, dan mengirimkan informasi tersebut kembali ke browser. Unit pemrosesan dan middleware virtual dapat dinyalakan dan dimatikan secara dinamis saat beban pengguna bertambah dan berkurang.

1. Processing Unit (PU)

Komponen Processing Unit

Unit Pemrosesan biasanya berisi modul aplikasi, bersama dengan kisi data dalam memori dan penyimpanan persisten asinkron opsional untuk failover. Ini juga berisi mesin replikasi yang digunakan oleh middleware tervirtualisasi untuk mereplikasi perubahan data yang dibuat oleh satu unit pemrosesan ke Processing Unit aktif lainnya.

2. Messaging Grid

Komponen Messaging Grid

Messaging grid, mengelola permintaan masukan dan informasi sesi. Saat permintaan masuk ke komponen middleware tervirtualisasi, komponen jaringan pesan menentukan komponen pemrosesan aktif mana yang tersedia untuk menerima permintaan dan meneruskan permintaan ke salah satu unit pemrosesan tersebut..

3. Data Grid

Komponen Data Grid

Komponen data-grid mungkin merupakan komponen yang paling penting dan krusial dalam pola ini. Kisi data berinteraksi dengan mesin replikasi data di setiap unit pemrosesan untuk mengelola replikasi data antar unit pemrosesan saat pembaruan data terjadi. Karena kotak perpesanan dapat meneruskan permintaan ke salah satu unit pemroses yang tersedia, setiap unit pemroses harus berisi data yang persis sama dalam kisi data dalam memorinya. Meskipun Gambar di atas menunjukkan replikasi data yang sinkron antara unit pemrosesan, pada kenyataannya hal ini dilakukan secara paralel secara asinkron dan sangat cepat, terkadang menyelesaikan sinkronisasi data dalam hitungan mikrodetik (sepersejuta detik).

4. Processing Grid

Komponen Processing Grid

The processing grid, adalah komponen opsional dalam middleware tervirtualisasi yang mengelola pemrosesan permintaan terdistribusi ketika terdapat beberapa unit pemrosesan, masing-masing menangani sebagian dari aplikasi. Jika permintaan masuk yang memerlukan koordinasi antara jenis unit pemrosesan (misalnya, unit pemrosesan pesanan dan unit pemrosesan pelanggan), jaringan pemrosesanlah yang memediasi dan mengatur permintaan antara dua unit pemrosesan tersebut.

5. Deployment Manager

Komponen deployment-manager mengelola startup dinamis dan shutdown unit pemrosesan berdasarkan kondisi beban. Komponen ini terus memantau waktu respons dan beban pengguna, dan memulai unit pemrosesan baru saat beban meningkat, dan mematikan unit pemrosesan saat beban berkurang. Ini adalah komponen penting untuk mencapai kebutuhan skalabilitas variabel dalam aplikasi.

D. Penerapan/Aplikasi dari Space-Based Architecture

Dari perspektif implementasi produk, Anda dapat mengimplementasikan banyak komponen arsitektur dalam pola ini melalui produk pihak ketiga seperti GemFire, JavaSpaces, PySpace, GigaSpaces, IBM Object Grid, nCache, dan Oracle Coherence. Karena penerapan pola ini sangat bervariasi dalam hal biaya dan kemampuan (khususnya waktu replikasi data), sebagai seorang arsitek, Anda harus terlebih dahulu menetapkan apa tujuan dan kebutuhan spesifik Anda sebelum membuat pilihan produk apa pun.

Berikut, inilah contoh Implementasi Program Aplikasi Space-Based Architecture sederhana menggunakan Python dan Java yang saya ambil dari ChatGPT :

1. Python

a. Menggunakan Library PySpace

Berikut adalah contoh implementasi program Space-Based Architecture dalam Python menggunakan Library PySpace :

from pyspace import pyspace
# Define data model
class Person:
    def __init__(self, id, name, age):
        self.id = id
        self.name = name
        self.age = age
# Define space configuration
space_config = {
    "name": "person_space",
    "partition": True,
    "partition_size": 1000,
    "nodes": ["node1", "node2", "node3"]
}
# Initialize space
person_space = pyspace.Space(space_config)
# Create and store objects in the space
person1 = Person(1, "John", 25)
person_space.put(person1.id, person1)
person2 = Person(2, "Jane", 30)
person_space.put(person2.id, person2)
# Retrieve objects from the space
person = person_space.get(1)
print(person.name)  # Output: John
# Update objects in the space
person1.age = 26
person_space.put(person1.id, person1)
# Remove objects from the space
person_space.delete(2)

Dalam contoh ini, kami mendefinisikan model data Person dan menginisialisasi konfigurasi space dengan nama "person_space" dan ukuran partisi 1000. Kami kemudian menginisialisasi pyspace.Space dengan konfigurasi yang telah ditentukan.

Kemudian kami membuat dua objek Person dan menyimpannya dalam space dengan menggunakan metode put(). Kami kemudian mengambil objek Person dengan id 1 dari space dengan menggunakan metode get() dan memperbarui usia orang tersebut dengan 26.

Terakhir, kami menghapus objek Person dengan id 2 dari space dengan menggunakan metode delete().

b. Tanpa menggunakan Library apapun

Berikut adalah contoh implementasi program Space-Based Architecture dalam Python tanpa menggunakan Library apapun :

import queue
import threading
# Define data model
class Person:
    def __init__(self, id, name, age):
        self.id = id
        self.name = name
        self.age = age
# Define space
class Space:
    def __init__(self):
        self.data = {}
        self.queue = queue.Queue()
        self.lock = threading.Lock()
        # Start worker thread
        t = threading.Thread(target=self.worker)
        t.daemon = True
        t.start()
    # Write data to space
    def write(self, obj):
        self.queue.put(('write', obj))
    # Read data from space by id
    def read(self, id):
        self.queue.put(('read', id))
        result = self.queue.get()
        if isinstance(result, Exception):
            raise result
        return result[1]
    # Update data in space
    def update(self, obj):
        self.queue.put(('update', obj))
        result = self.queue.get()
        if isinstance(result, Exception):
            raise result
        return result[1]
    # Remove data from space by id
    def remove(self, id):
        self.queue.put(('remove', id))
    # Worker thread
    def worker(self):
        while True:
            op, data = self.queue.get()
            try:
                if op == 'write':
                    with self.lock:
                        self.data[data.id] = data
                elif op == 'read':
                    with self.lock:
                        if data not in self.data:
                            raise KeyError('Object not found')
                        result = self.data[data]
                elif op == 'update':
                    with self.lock:
                        self.data[data.id] = data
                elif op == 'remove':
                    with self.lock:
                        del self.data[data]
            except Exception as e:
                self.queue.put(e)
            else:
                self.queue.put(result)
# Example usage
space = Space()
person1 = Person(1, 'John', 25)
space.write(person1)
person2 = Person(2, 'Jane', 30)
space.write(person2)
person = space.read(1)
print(person.name)  # Output: John
person1.age = 26
space.update(person1)
# space.remove(2)

Dalam contoh ini, kami mendefinisikan model data Person dan kemudian mendefinisikan kelas Space sebagai pengganti space pada implementasi yang menggunakan library.

Kami menggunakan antrean untuk menerima perintah dan menggunakan pengunci untuk menghindari konflik ketika menulis atau membaca data dari self.data. Kami kemudian memulai thread kerja yang akan memproses setiap perintah yang diberikan dalam antrian.

Kami kemudian membuat dua objek Person dan menyimpannya dalam space dengan menggunakan metode write(). Kami kemudian mengambil objek Person dengan id 1 dari space dengan menggunakan metode read() dan memperbarui usia orang tersebut dengan 26 dengan menggunakan metode update().

Terakhir, kami menghapus objek Person dengan id 2 dari space dengan menggunakan metode remove().

2. Java

a. Menggunakan Library GigaSpaces

Berikut adalah contoh implementasi program Space-Based Architecture dalam Java menggunakan Library GigaSpaces :

import org.openspaces.core.GigaSpace;
import org.openspaces.core.GigaSpaceConfigurer;
import org.openspaces.core.space.UrlSpaceConfigurer;
// Define data model
public class Person {
    public int id;
    public String name;
    public int age;
}
public class Main {
    public static void main(String[] args) {
        // Initialize space configuration
        UrlSpaceConfigurer urlSpaceConfigurer = new UrlSpaceConfigurer("jini://localhost/*/person_space");
        
        // Initialize GigaSpace instance
        GigaSpace gigaSpace = new GigaSpaceConfigurer(urlSpaceConfigurer).gigaSpace();
        // Create and store objects in the space
        Person person1 = new Person();
        person1.id = 1;
        person1.name = "John";
        person1.age = 25;
        gigaSpace.write(person1);
        Person person2 = new Person();
        person2.id = 2;
        person2.name = "Jane";
        person2.age = 30;
        gigaSpace.write(person2);
        // Retrieve objects from the space
        Person person = gigaSpace.readById(Person.class, 1);
        System.out.println(person.name);  // Output: John
        // Update objects in the space
        person1.age = 26;
        gigaSpace.write(person1);
        // Remove objects from the space
        gigaSpace.takeById(Person.class, 2);
    }
}

Dalam contoh ini, kami mendefinisikan model data Person dan menginisialisasi konfigurasi space dengan menggunakan UrlSpaceConfigurer dan nama space "person_space". Kami kemudian menginisialisasi GigaSpace dengan konfigurasi yang telah ditentukan.

Kemudian kami membuat dua objek Person dan menyimpannya dalam space dengan menggunakan metode write(). Kami kemudian mengambil objek Person dengan id 1 dari space dengan menggunakan metode readById() dan memperbarui usia orang tersebut dengan 26 dengan menggunakan metode write().

Terakhir, kami menghapus objek Person dengan id 2 dari space dengan menggunakan metode takeById().

b. Tanpa menggunakan Library apapun

Berikut adalah contoh implementasi program Space-Based Architecture dalam Java tanpa menggunakan Library apapun :

import java.util.LinkedList;
import java.util.Queue;
class Person {
    private int id;
    private String name;
    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public String getName() {
        return name;
    }
}
class Space {
    private Queue<Object[]> queue = new LinkedList<>();
    public synchronized void write(Object[] data) {
        queue.offer(data);
        notify();
    }
    public synchronized Object[] take() throws InterruptedException {
        while (queue.isEmpty()) {
            wait();
        }
        return queue.poll();
    }
}
class Worker implements Runnable {
    private Space space;
    public Worker(Space space) {
        this.space = space;
    }
    @Override
    public void run() {
        try {
            while (true) {
                Object[] data = space.take();
                String op = (String) data[0];
                if (op.equals("create")) {
                    Person person = (Person) data[1];
                    space.write(new Object[]{"created", person.getId()});
                } else if (op.equals("read")) {
                    int id = (int) data[1];
                    Person person = new Person(id, "John");
                    space.write(new Object[]{"read", person});
                } else if (op.equals("update")) {
                    Person person = (Person) data[1];
                    space.write(new Object[]{"updated", person.getId()});
                } else if (op.equals("delete")) {
                    int id = (int) data[1];
                    space.write(new Object[]{"deleted", id});
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}
public class SpaceBasedArchitecture {
    public static void main(String[] args) throws InterruptedException {
        Space space = new Space();
        Thread thread = new Thread(new Worker(space));
        thread.start();
        // Create a person
        Person person1 = new Person(1, "Alice");
        space.write(new Object[]{"create", person1});
        Object[] result1 = space.take();
        System.out.println("Created person with ID " + result1[1]);
        // Read a person
        space.write(new Object[]{"read", 1});
        Object[] result2 = space.take();
        Person person2 = (Person) result2[1];
        System.out.println("Read person with ID " + person2.getId() + " and name " + person2.getName());
        // Update a person
        Person person3 = new Person(1, "Bob");
        space.write(new Object[]{"update", person3});
        Object[] result3 = space.take();
        System.out.println("Updated person with ID " + result3[1]);
        // Delete a person
        space.write(new Object[]{"delete", 1});
        Object[] result4 = space.take();
        System.out.println("Deleted person with ID " + result4[1]);
        thread.interrupt();
    }
}

Program di atas terdiri dari tiga kelas: Person, Space, dan Worker. Person adalah kelas yang merepresentasikan objek yang disimpan di dalam Space. Space adalah kelas yang merepresentasikan space yang berlangsungnya operasi CRUD dalam penggunaan Space-Based Architecture. Worker adalah kelas yang merepresentasikan thread yang bekerja pada space.

Pada kelas Space, terdapat method write untuk menambahkan data ke ruang data, method take untuk mengambil data dari ruang data, dan method watch untuk memonitor perubahan data pada ruang data. Method write dan take menggunakan synchronized untuk memastikan bahwa operasi yang dilakukan tidak terjadi secara bersamaan.

Pada kelas Tuple, terdapat beberapa method, yaitu get, set, dan getFields. Method get dan set digunakan untuk mengambil dan mengubah nilai atribut pada objek Tuple, sedangkan method getFields digunakan untuk mengambil semua nilai atribut pada objek Tuple.

Kelas Person adalah kelas turunan dari Tuple yang memiliki atribut name dan age. Pada contoh di atas, objek Person dibuat dan dimasukkan ke dalam Space menggunakan method write, kemudian objek Person tersebut diambil kembali menggunakan method take. Setelah itu, nilai atribut name pada objek Person diubah menjadi "John" menggunakan method set, dan hasilnya diperiksa dengan mengambil kembali objek Person tersebut menggunakan method take.

Program di atas belum menggunakan library apapun, sehingga implementasi Space-Based Architecture dibangun secara manual dengan menggunakan thread dan wait-notify mechanism untuk mengatur sinkronisasi antar thread. Namun, dalam implementasi yang lebih kompleks, biasanya menggunakan library yang disediakan oleh platform, seperti Apache Geode, GigaSpaces, atau Oracle Coherence.

Demikianlah penjelasan tentang Space-Based Architecture. Semoga bermanfaat bagi Software Developer/Engineer dan juga untuk Mahasiswa IT (Informatika).

Terima Kasih 😄😘👌👍 :)

Wassalamu‘alaikum wr. wb.