M

MLOG

Bahasa Indonesia

Pelajari bagaimana Event Sourcing dapat merevolusi implementasi jejak audit Anda, menawarkan keterlacakan, integritas data, dan ketahanan sistem yang tak tertandingi. Jelajahi contoh praktis dan strategi implementasi.

Event Sourcing: Implementasi Jejak Audit untuk Sistem yang Tangguh dan Dapat Dilacak

Dalam lanskap digital yang kompleks dan saling terhubung saat ini, memelihara jejak audit yang tangguh dan komprehensif adalah hal yang terpenting. Ini tidak hanya sering kali menjadi persyaratan peraturan, tetapi juga krusial untuk debugging, analisis keamanan, dan memahami evolusi sistem Anda. Event Sourcing, sebuah pola arsitektural yang menangkap semua perubahan pada status aplikasi sebagai urutan peristiwa (event), menawarkan solusi yang elegan dan kuat untuk mengimplementasikan jejak audit yang andal, dapat diaudit, dan dapat diperluas.

Apa itu Event Sourcing?

Aplikasi tradisional biasanya hanya menyimpan status data saat ini dalam sebuah basis data. Pendekatan ini menyulitkan untuk merekonstruksi status masa lalu atau memahami rangkaian peristiwa yang mengarah ke status saat ini. Sebaliknya, Event Sourcing berfokus pada penangkapan setiap perubahan signifikan pada status aplikasi sebagai peristiwa yang imutabel (tidak dapat diubah). Peristiwa-peristiwa ini disimpan dalam event store yang bersifat append-only (hanya bisa ditambah), membentuk catatan lengkap dan kronologis dari semua tindakan dalam sistem.

Anggap saja seperti buku besar rekening bank. Alih-alih hanya mencatat saldo saat ini, setiap setoran, penarikan, dan transfer dicatat sebagai peristiwa terpisah. Dengan memutar ulang (replaying) peristiwa-peristiwa ini, Anda dapat merekonstruksi status akun pada titik waktu mana pun.

Mengapa Menggunakan Event Sourcing untuk Jejak Audit?

Event Sourcing menawarkan beberapa keuntungan menarik untuk mengimplementasikan jejak audit:

Mengimplementasikan Event Sourcing untuk Jejak Audit: Panduan Langkah-demi-Langkah

Berikut adalah panduan praktis untuk mengimplementasikan Event Sourcing untuk jejak audit:

1. Identifikasi Peristiwa Kunci

Langkah pertama adalah mengidentifikasi peristiwa kunci yang ingin Anda tangkap dalam jejak audit Anda. Peristiwa ini harus mewakili perubahan signifikan pada status aplikasi. Pertimbangkan tindakan seperti:

Contoh: Untuk platform e-commerce, peristiwa kunci mungkin termasuk "OrderCreated," "PaymentReceived," "OrderShipped," "ProductAddedToCart," dan "UserProfileUpdated."

2. Definisikan Struktur Peristiwa

Setiap peristiwa harus memiliki struktur yang terdefinisi dengan baik yang mencakup informasi berikut:

Contoh: Peristiwa "OrderCreated" mungkin memiliki struktur berikut:

{
  "eventType": "OrderCreated",
  "eventData": {
    "orderId": "12345",
    "customerId": "67890",
    "orderDate": "2023-10-27T10:00:00Z",
    "totalAmount": 100.00,
    "currency": "USD",
    "shippingAddress": {
      "street": "123 Main St",
      "city": "Anytown",
      "state": "CA",
      "zipCode": "91234",
      "country": "USA"
    }
  },
  "timestamp": "2023-10-27T10:00:00Z",
  "userId": "user123",
  "transactionId": "tx12345",
  "correlationId": "corr123",
  "metadata": {
    "ipAddress": "192.168.1.1",
    "browser": "Chrome",
    "location": {
       "latitude": 34.0522,
       "longitude": -118.2437
    }
  }
}

3. Pilih Event Store

Event store adalah repositori pusat untuk menyimpan peristiwa. Ini harus berupa basis data append-only yang dioptimalkan untuk menulis dan membaca urutan peristiwa. Beberapa opsi tersedia:

Saat memilih event store, pertimbangkan faktor-faktor seperti:

4. Implementasikan Publikasi Peristiwa

Ketika sebuah peristiwa terjadi, aplikasi Anda perlu mempublikasikannya ke event store. Ini biasanya melibatkan langkah-langkah berikut:

Contoh (menggunakan EventStoreService hipotetis):

public class OrderService {

  private final EventStoreService eventStoreService;

  public OrderService(EventStoreService eventStoreService) {
    this.eventStoreService = eventStoreService;
  }

  public void createOrder(Order order, String userId) {
    // ... logika bisnis untuk membuat pesanan ...

    OrderCreatedEvent event = new OrderCreatedEvent(
        order.getOrderId(),
        order.getCustomerId(),
        order.getOrderDate(),
        order.getTotalAmount(),
        order.getCurrency(),
        order.getShippingAddress()
    );

    eventStoreService.appendEvent("order", order.getOrderId(), event, userId);
  }
}

public class EventStoreService {

  public void appendEvent(String streamName, String entityId, Object event, String userId) {
    // Buat objek peristiwa
    EventRecord eventRecord = new EventRecord(
        UUID.randomUUID(), // eventId
        streamName,  // streamName
        entityId,   // entityId
        event.getClass().getName(), // eventType
        toJson(event),  // eventData
        Instant.now().toString(), // timestamp
        userId  // userId
    );

    // Serialisasi peristiwa
    String serializedEvent = toJson(eventRecord);

    // Tambahkan peristiwa ke event store (implementasi spesifik untuk event store yang dipilih)
    storeEventInDatabase(serializedEvent);

    // Publikasikan peristiwa ke pelanggan (opsional)
    publishEventToMessageQueue(serializedEvent);
  }

  // Metode placeholder untuk interaksi database dan antrian pesan
  private void storeEventInDatabase(String serializedEvent) {
    // Implementasi untuk menyimpan peristiwa di database
    System.out.println("Menyimpan event di database: " + serializedEvent);
  }

  private void publishEventToMessageQueue(String serializedEvent) {
    // Implementasi untuk mempublikasikan peristiwa ke antrian pesan
    System.out.println("Mempublikasikan event ke antrian pesan: " + serializedEvent);
  }

  private String toJson(Object obj) {
    // Implementasi untuk melakukan serialisasi peristiwa ke JSON
    try {
      ObjectMapper mapper = new ObjectMapper();
      return mapper.writeValueAsString(obj);
    } catch (Exception e) {
      throw new RuntimeException("Gagal melakukan serialisasi event ke JSON", e);
    }
  }
}


class EventRecord {
  private final UUID eventId;
  private final String streamName;
  private final String entityId;
  private final String eventType;
  private final String eventData;
  private final String timestamp;
  private final String userId;

  public EventRecord(UUID eventId, String streamName, String entityId, String eventType, String eventData, String timestamp, String userId) {
    this.eventId = eventId;
    this.streamName = streamName;
    this.entityId = entityId;
    this.eventType = eventType;
    this.eventData = eventData;
    this.timestamp = timestamp;
    this.userId = userId;
  }

  // Getters

  @Override
  public String toString() {
    return "EventRecord{" +
        "eventId=" + eventId +
        ", streamName='" + streamName + '\'' +
        ", entityId='" + entityId + '\'' +
        ", eventType='" + eventType + '\'' +
        ", eventData='" + eventData + '\'' +
        ", timestamp='" + timestamp + '\'' +
        ", userId='" + userId + '\'' +
        '}';
  }
}

class OrderCreatedEvent {
    private final String orderId;
    private final String customerId;
    private final String orderDate;
    private final double totalAmount;
    private final String currency;
    private final String shippingAddress;

    public OrderCreatedEvent(String orderId, String customerId, String orderDate, double totalAmount, String currency, String shippingAddress) {
        this.orderId = orderId;
        this.customerId = customerId;
        this.orderDate = orderDate;
        this.totalAmount = totalAmount;
        this.currency = currency;
        this.shippingAddress = shippingAddress;
    }

    // Getters for all fields

    public String getOrderId() { return orderId; }
    public String getCustomerId() { return customerId; }
    public String getOrderDate() { return orderDate; }
    public double getTotalAmount() { return totalAmount; }
    public String getCurrency() { return currency; }
    public String getShippingAddress() { return shippingAddress; }

    @Override
    public String toString() {
        return "OrderCreatedEvent{" +
                "orderId='" + orderId + '\'' +
                ", customerId='" + customerId + '\'' +
                ", orderDate='" + orderDate + '\'' +
                ", totalAmount=" + totalAmount +
                ", currency='" + currency + '\'' +
                ", shippingAddress='" + shippingAddress + '\'' +
                '}';
    }
}

class Order {
  private final String orderId;
  private final String customerId;
  private final String orderDate;
  private final double totalAmount;
  private final String currency;
  private final String shippingAddress;

  public Order(String orderId, String customerId, String orderDate, double totalAmount, String currency, String shippingAddress) {
        this.orderId = orderId;
        this.customerId = customerId;
        this.orderDate = orderDate;
        this.totalAmount = totalAmount;
        this.currency = currency;
        this.shippingAddress = shippingAddress;
    }

    // Getters for all fields

    public String getOrderId() { return orderId; }
    public String getCustomerId() { return customerId; }
    public String getOrderDate() { return orderDate; }
    public double getTotalAmount() { return totalAmount; }
    public String getCurrency() { return currency; }
    public String getShippingAddress() { return shippingAddress; }

    @Override
    public String toString() {
        return "Order{" +
                "orderId='" + orderId + '\'' +
                ", customerId='" + customerId + '\'' +
                ", orderDate='" + orderDate + '\'' +
                ", totalAmount=" + totalAmount +
                ", currency='" + currency + '\'' +
                ", shippingAddress='" + shippingAddress + '\'' +
                '}';
    }
}

5. Bangun Model Baca (Projections)

Meskipun event store menyediakan riwayat lengkap dari semua perubahan, sering kali tidak efisien untuk melakukan kueri langsung untuk operasi baca. Sebaliknya, Anda dapat membangun model baca, juga dikenal sebagai proyeksi (projections), yang dioptimalkan untuk pola kueri tertentu. Model baca ini berasal dari aliran peristiwa dan diperbarui secara asinkron saat peristiwa baru dipublikasikan.

Contoh: Anda mungkin membuat model baca yang berisi daftar semua pesanan untuk pelanggan tertentu, atau model baca yang merangkum data penjualan untuk produk tertentu.

Untuk membangun model baca, Anda berlangganan aliran peristiwa dan memproses setiap peristiwa. Untuk setiap peristiwa, Anda memperbarui model baca yang sesuai.

Contoh:

public class OrderSummaryReadModelUpdater {

    private final OrderSummaryRepository orderSummaryRepository;

    public OrderSummaryReadModelUpdater(OrderSummaryRepository orderSummaryRepository) {
        this.orderSummaryRepository = orderSummaryRepository;
    }

    public void handle(OrderCreatedEvent event) {
        OrderSummary orderSummary = new OrderSummary(
                event.getOrderId(),
                event.getCustomerId(),
                event.getOrderDate(),
                event.getTotalAmount(),
                event.getCurrency()
        );

        orderSummaryRepository.save(orderSummary);
    }

    // Penangan event lain untuk PaymentReceivedEvent, OrderShippedEvent, dll.
}

interface OrderSummaryRepository {
    void save(OrderSummary orderSummary);
}

class OrderSummary {
    private final String orderId;
    private final String customerId;
    private final String orderDate;
    private final double totalAmount;
    private final String currency;

    public OrderSummary(String orderId, String customerId, String orderDate, double totalAmount, String currency) {
        this.orderId = orderId;
        this.customerId = customerId;
        this.orderDate = orderDate;
        this.totalAmount = totalAmount;
        this.currency = currency;
    }
    //Getters
}

6. Amankan Event Store

Event store berisi data sensitif, jadi sangat penting untuk mengamankannya dengan benar. Pertimbangkan langkah-langkah keamanan berikut:

7. Implementasikan Audit dan Pelaporan

Setelah Anda mengimplementasikan Event Sourcing, Anda dapat menggunakan aliran peristiwa untuk menghasilkan laporan audit dan melakukan analisis keamanan. Anda dapat membuat kueri ke event store untuk menemukan semua peristiwa yang terkait dengan pengguna, transaksi, atau entitas tertentu. Anda juga dapat menggunakan aliran peristiwa untuk merekonstruksi status sistem pada titik waktu mana pun.

Contoh: Anda mungkin menghasilkan laporan yang menunjukkan semua perubahan yang dibuat pada profil pengguna tertentu selama periode waktu tertentu, atau laporan yang menunjukkan semua transaksi yang diprakarsai oleh pengguna tertentu.

Pertimbangkan kemampuan pelaporan berikut:

Tantangan Event Sourcing

Meskipun Event Sourcing menawarkan banyak manfaat, ia juga menghadirkan beberapa tantangan:

Praktik Terbaik untuk Event Sourcing

Untuk mengurangi tantangan Event Sourcing, ikuti praktik terbaik berikut:

Contoh Event Sourcing di Dunia Nyata

Event Sourcing digunakan di berbagai industri dan aplikasi, termasuk:

Kesimpulan

Event Sourcing adalah pola arsitektural yang kuat yang dapat merevolusi implementasi jejak audit Anda. Ini memberikan keterlacakan, integritas data, dan ketahanan sistem yang tak tertandingi. Meskipun menghadirkan beberapa tantangan, manfaat Event Sourcing sering kali lebih besar daripada biayanya, terutama untuk sistem yang kompleks dan kritis. Dengan mengikuti praktik terbaik yang diuraikan dalam panduan ini, Anda dapat berhasil mengimplementasikan Event Sourcing dan membangun sistem yang tangguh dan dapat diaudit.

Bacaan Lebih Lanjut

Event Sourcing: Implementasi Jejak Audit untuk Sistem yang Tangguh dan Dapat Dilacak | MLOG