Cara Bergabung dengan MySQL dan Postgres dalam Tampilan Terwujud Langsung

Saat Anda mengerjakan proyek yang terdiri dari banyak layanan mikro, kemungkinan besar proyek tersebut juga menyertakan banyak basis data.

Misalnya, Anda mungkin memiliki database MySQL dan database PostgreSQL, keduanya berjalan di server terpisah.

Biasanya, untuk menggabungkan data dari dua database, Anda harus memperkenalkan layanan mikro baru yang akan menggabungkan data bersama. Tapi ini akan meningkatkan kompleksitas sistem.

Dalam tutorial ini, kita akan menggunakan Materialize untuk menggabungkan MySQL dan Postgres dalam tampilan materialisasi langsung. Kami kemudian akan dapat menanyakannya secara langsung dan mendapatkan hasil kembali dari kedua database secara real-time menggunakan SQL standar.

Materialize adalah database streaming yang tersedia sumber yang ditulis dalam Rust yang menyimpan hasil kueri SQL (tampilan terwujud) di memori saat data berubah.

Tutorial ini menyertakan proyek demo yang dapat Anda mulai gunakan docker-compose .

Proyek demo yang akan kami gunakan akan memantau pesanan di situs web tiruan kami. Ini akan menghasilkan acara yang nantinya dapat digunakan untuk mengirim pemberitahuan ketika kereta telah ditinggalkan untuk waktu yang lama.

Arsitektur proyek demo adalah sebagai berikut:

Prasyarat

Semua layanan yang akan kami gunakan dalam demo akan berjalan di dalam wadah Docker, sehingga Anda tidak perlu menginstal layanan tambahan apa pun di laptop atau server Anda selain Docker dan Docker Compose.

Jika Anda belum menginstal Docker dan Docker Compose, Anda dapat mengikuti petunjuk resmi tentang cara melakukannya di sini:

Instal Docker
Instal Docker Compose

Ikhtisar

Seperti yang ditunjukkan pada diagram di atas, kita akan memiliki komponen berikut:

Layanan tiruan untuk terus menghasilkan pesanan.
Pesanan akan disimpan di database MySQL .
Saat penulisan database terjadi, Debezium mengalirkan perubahan dari MySQL ke Redpanda topik.
Kami juga akan memiliki Postgres database tempat kami bisa mendapatkan pengguna kami.
Kemudian, kami akan memasukkan topik Redpanda ini ke dalam Mewujudkan langsung bersama pengguna dari database Postgres.
Di Materialize, kami akan menggabungkan pesanan dan pengguna kami, melakukan beberapa pemfilteran, dan membuat tampilan terwujud yang menunjukkan informasi keranjang yang ditinggalkan.
Kami kemudian akan membuat sink untuk mengirim data keranjang yang ditinggalkan ke topik Redpanda baru.
Pada akhirnya kita akan menggunakan Metabase untuk memvisualisasikan data.
Anda dapat, nanti, menggunakan informasi dari topik baru tersebut untuk mengirimkan pemberitahuan kepada pengguna Anda dan mengingatkan mereka bahwa mereka memiliki keranjang yang ditinggalkan.

Sebagai catatan tambahan di sini, Anda akan baik-baik saja menggunakan Kafka daripada Redpanda. Saya menyukai kesederhanaan yang dihadirkan Redpanda, karena Anda dapat menjalankan satu instance Redpanda alih-alih semua komponen Kafka.

Cara Menjalankan Demo

Pertama, mulailah dengan mengkloning repositori:

git clone https://github.com/bobbyiliev/materialize-tutorials.git

Setelah itu Anda dapat mengakses direktori:

cd materialize-tutorials/mz-join-mysql-and-postgresql

Mari kita mulai dengan menjalankan wadah Redpanda terlebih dahulu:

docker-compose up -d redpanda

Buat gambar:

docker-compose build

Terakhir, mulai semua layanan:

docker-compose up -d

Untuk Meluncurkan CLI Materialize, Anda dapat menjalankan perintah berikut:

docker-compose run mzcli

Ini hanyalah jalan pintas ke wadah Docker dengan postgres-client pra-instal. Jika Anda sudah memiliki psql anda dapat menjalankan psql -U materialize -h localhost -p 6875 materialize sebagai gantinya.

Cara Membuat Sumber Kafka yang Terwujud

Sekarang Anda berada di Materialize CLI, mari kita definisikan orders tabel di mysql.shop database sebagai sumber Redpanda:

CREATE SOURCE orders
FROM KAFKA BROKER 'redpanda:9092' TOPIC 'mysql.shop.orders'
FORMAT AVRO USING CONFLUENT SCHEMA REGISTRY 'http://redpanda:8081'
ENVELOPE DEBEZIUM;

Jika Anda memeriksa kolom yang tersedia dari orders source dengan menjalankan pernyataan berikut:

SHOW COLUMNS FROM orders;

Anda akan dapat melihat bahwa, saat Materialize menarik data skema pesan dari registri Redpanda, ia mengetahui jenis kolom yang akan digunakan untuk setiap atribut:

    name      | nullable |   type
--------------+----------+-----------
 id           | f        | bigint
 user_id      | t        | bigint
 order_status | t        | integer
 price        | t        | numeric
 created_at   | f        | text
 updated_at   | t        | timestamp

Cara Membuat Tampilan Terwujud

Selanjutnya, kita akan membuat Tampilan Terwujud pertama kita, untuk mendapatkan semua data dari orders Sumber panda merah:

CREATE MATERIALIZED VIEW orders_view AS
SELECT * FROM orders;

CREATE MATERIALIZED VIEW abandoned_orders AS
    SELECT
        user_id,
        order_status,
        SUM(price) as revenue,
        COUNT(id) AS total
    FROM orders_view
    WHERE order_status=0
    GROUP BY 1,2;

Anda sekarang dapat menggunakan SELECT * FROM abandoned_orders; untuk melihat hasilnya:

SELECT * FROM abandoned_orders;

Untuk informasi lebih lanjut tentang membuat tampilan terwujud, lihat bagian Tampilan Terwujud dari dokumentasi Mewujudkan.

Cara Membuat Sumber Postgres

Ada dua cara untuk membuat sumber Postgres di Materialize:

Menggunakan Debezium seperti yang kami lakukan dengan sumber MySQL.
Menggunakan Sumber Materialize Postgres, yang memungkinkan Anda menghubungkan Materialize langsung ke Postgres sehingga Anda tidak perlu menggunakan Debezium.

Untuk demo ini, kami akan menggunakan Postgres Materialize Source hanya sebagai demonstrasi cara menggunakannya, tetapi jangan ragu untuk menggunakan Debezium sebagai gantinya.

Untuk membuat Sumber Materialize Postgres jalankan pernyataan berikut:

CREATE MATERIALIZED SOURCE "mz_source" FROM POSTGRES
CONNECTION 'user=postgres port=5432 host=postgres dbname=postgres password=postgres'
PUBLICATION 'mz_source';

Ringkasan singkat dari pernyataan di atas:

MATERIALIZED :Mewujudkan data sumber PostgreSQL. Semua data disimpan dalam memori dan membuat sumber dapat dipilih secara langsung.
mz_source :Nama untuk sumber PostgreSQL.
CONNECTION :Parameter koneksi PostgreSQL.
PUBLICATION :Publikasi PostgreSQL, berisi tabel yang akan dialirkan ke Materialize.

Setelah kita membuat sumber PostgreSQL, agar dapat mengkueri tabel PostgreSQL, kita perlu membuat tampilan yang mewakili tabel asli publikasi upstream.

Dalam kasus kami, kami hanya memiliki satu tabel yang disebut users jadi pernyataan yang perlu kita jalankan adalah:

CREATE VIEWS FROM SOURCE mz_source (users);

Untuk melihat tampilan yang tersedia, jalankan pernyataan berikut:

SHOW FULL VIEWS;

Setelah selesai, Anda dapat langsung menanyakan tampilan baru:

SELECT * FROM users;

Selanjutnya, mari lanjutkan dan buat beberapa tampilan lagi.

Cara Membuat Wastafel Kafka

Sink memungkinkan Anda mengirim data dari Materialize ke sumber eksternal.

Untuk Demo ini, kami akan menggunakan Redpanda.

Redpanda kompatibel dengan Kafka API dan Materialize dapat memproses data darinya seperti halnya memproses data dari sumber Kafka.

Mari kita buat tampilan terwujud, yang akan menampung semua pesanan yang belum dibayar dalam jumlah besar:

 CREATE MATERIALIZED VIEW high_value_orders AS
      SELECT
        users.id,
        users.email,
        abandoned_orders.revenue,
        abandoned_orders.total
      FROM users
      JOIN abandoned_orders ON abandoned_orders.user_id = users.id
      GROUP BY 1,2,3,4
      HAVING revenue > 2000;

Seperti yang Anda lihat, di sini kita sebenarnya bergabung dengan users tampilan yang menyerap data langsung dari sumber Postgres kami, dan abandond_orders tampilan yang menyerap data dari topik Redpanda, bersama-sama.

Mari kita buat Sink di mana kita akan mengirim data tampilan terwujud di atas:

CREATE SINK high_value_orders_sink
    FROM high_value_orders
    INTO KAFKA BROKER 'redpanda:9092' TOPIC 'high-value-orders-sink'
    FORMAT AVRO USING
    CONFLUENT SCHEMA REGISTRY 'http://redpanda:8081';

Sekarang jika Anda terhubung ke wadah Redpanda dan menggunakan rpk topic consume perintah, Anda akan dapat membaca catatan dari topik.

Namun, untuk saat ini, kami tidak dapat melihat pratinjau hasil dengan rpk karena berformat AVRO. Redpanda kemungkinan besar akan menerapkan ini di masa mendatang, tetapi untuk saat ini, kami sebenarnya dapat mengalirkan topik tersebut kembali ke Materialize untuk mengonfirmasi formatnya.

Pertama, dapatkan nama topik yang telah dibuat secara otomatis:

SELECT topic FROM mz_kafka_sinks;

Keluaran:

                              topic
-----------------------------------------------------------------
 high-volume-orders-sink-u12-1637586945-13670686352905873426

Untuk informasi lebih lanjut tentang bagaimana nama topik dibuat, lihat dokumentasi di sini.

Kemudian buat Sumber Terwujud baru dari topik Redpanda ini:

CREATE MATERIALIZED SOURCE high_volume_orders_test
FROM KAFKA BROKER 'redpanda:9092' TOPIC ' high-volume-orders-sink-u12-1637586945-13670686352905873426'
FORMAT AVRO USING CONFLUENT SCHEMA REGISTRY 'http://redpanda:8081';

Pastikan untuk mengubah nama topik yang sesuai!

Terakhir, tanyakan tampilan baru yang terwujud ini:

SELECT * FROM high_volume_orders_test LIMIT 2;

Sekarang setelah Anda memiliki data dalam topik, Anda dapat membuat layanan lain terhubung dan menggunakannya, lalu memicu email atau peringatan misalnya.

Cara Menghubungkan Metabase

Untuk mengakses instance Metabase, kunjungi http://localhost:3030 jika Anda menjalankan demo secara lokal atau http://your_server_ip:3030 jika Anda menjalankan demo di server. Kemudian ikuti langkah-langkah untuk menyelesaikan penyiapan Metabase.

Pastikan untuk memilih Materialize sebagai sumber data.

Setelah siap, Anda akan dapat memvisualisasikan data Anda seperti yang Anda lakukan dengan database PostgreSQL standar.

Cara Menghentikan Demo

Untuk menghentikan semua layanan, jalankan perintah berikut:

docker-compose down

Kesimpulan

Seperti yang Anda lihat, ini adalah contoh yang sangat sederhana tentang bagaimana menggunakan Materialize. Anda dapat menggunakan Materialize untuk menyerap data dari berbagai sumber dan kemudian mengalirkannya ke berbagai tujuan.

Sumber daya yang berguna:

CREATE SOURCE: PostgreSQL
CREATE SOURCE
CREATE VIEWS
SELECT