Cara Mengonfigurasi PostgreSQL Sharding dengan ClusterControl

Terkadang sulit untuk mengelola sejumlah besar data di perusahaan, terutama dengan peningkatan eksponensial Analisis Data dan penggunaan IoT. Bergantung pada ukurannya, jumlah data ini dapat memengaruhi kinerja sistem Anda dan Anda mungkin perlu menskalakan basis data Anda atau menemukan cara untuk memperbaikinya. Ada berbagai cara untuk menskalakan database PostgreSQL Anda dan salah satunya adalah Sharding. Di blog ini, kita akan melihat apa itu Sharding dan bagaimana mengonfigurasinya di PostgreSQL menggunakan ClusterControl untuk menyederhanakan tugas.

Apa itu Sharding?

Sharding adalah tindakan mengoptimalkan database dengan memisahkan data dari tabel besar menjadi beberapa tabel kecil. Tabel yang lebih kecil adalah Shards (atau partisi). Partisi dan Sharding adalah konsep yang serupa. Perbedaan utama adalah bahwa sharding menyiratkan data tersebar di beberapa komputer sementara partisi adalah tentang pengelompokan subset data dalam satu contoh database.

Ada dua jenis Sharding:

• Horizontal Sharding:Setiap tabel baru memiliki skema yang sama dengan tabel besar tetapi barisnya unik. Ini berguna ketika kueri cenderung mengembalikan subset baris yang sering dikelompokkan bersama.

• Vertical Sharding:Setiap tabel baru memiliki skema yang merupakan subset dari skema tabel asli. Ini berguna ketika kueri cenderung hanya mengembalikan sebagian kolom data.

Mari kita lihat contohnya:

Tabel Asli

Sharding Vertikal

Sharding Horizontal

Sekarang setelah kita meninjau beberapa konsep Sharding, mari lanjutkan ke langkah berikutnya.

Bagaimana Cara Menyebarkan Cluster PostgreSQL?

Kami akan menggunakan ClusterControl untuk tugas ini. Jika Anda belum menggunakan ClusterControl, Anda dapat menginstalnya dan menyebarkan atau mengimpor database PostgreSQL Anda saat ini dengan memilih opsi "Impor" dan ikuti langkah-langkah untuk memanfaatkan semua fitur ClusterControl seperti pencadangan, failover otomatis, peringatan, pemantauan, dan lainnya .

Untuk melakukan penerapan dari ClusterControl, cukup pilih opsi “Deploy” dan ikuti petunjuk yang muncul.

Saat memilih PostgreSQL, Anda harus menentukan Pengguna, Kunci, atau Kata Sandi Anda, dan Port untuk terhubung dengan SSH ke server Anda. Anda juga dapat menambahkan nama untuk klaster baru Anda dan jika mau, Anda juga dapat menggunakan ClusterControl untuk menginstal perangkat lunak dan konfigurasi yang sesuai untuk Anda.

Setelah menyiapkan informasi akses SSH, Anda perlu menentukan kredensial basis data , versi, dan datadir (opsional). Anda juga dapat menentukan repositori mana yang akan digunakan.

Untuk langkah selanjutnya, Anda perlu menambahkan server Anda ke cluster yang akan Anda buat menggunakan Alamat IP atau Hostname.

Pada langkah terakhir, Anda dapat memilih apakah replikasi Anda akan Sinkron atau Tidak sinkron, lalu cukup tekan “Deploy”.

Setelah tugas selesai, Anda akan melihat cluster PostgreSQL baru Anda di layar ClusterControl utama.

Sekarang setelah cluster Anda dibuat, Anda dapat melakukan beberapa tugas di dalamnya seperti menambahkan penyeimbang beban (HAProxy), penyambung koneksi (pgBouncer), atau replika baru.

Ulangi proses untuk memiliki setidaknya dua kluster PostgreSQL terpisah untuk mengonfigurasi Sharding, yang merupakan langkah berikutnya.

Bagaimana Mengonfigurasi PostgreSQL Sharding?

Sekarang kita akan mengkonfigurasi Sharding menggunakan Partisi PostgreSQL dan Pembungkus Data Asing (FDW). Fungsionalitas ini memungkinkan PostgreSQL untuk mengakses data yang disimpan di server lain. Ini adalah ekstensi yang tersedia secara default di instalasi PostgreSQL umum.

Kami akan menggunakan lingkungan berikut:

Servers: Shard1 - 10.10.10.137, Shard2 - 10.10.10.138
Database User: admindb
Table: customers

Untuk mengaktifkan ekstensi FDW, Anda hanya perlu menjalankan perintah berikut di server utama Anda, dalam hal ini Shard1:

postgres=# CREATE EXTENSION postgres_fdw;
CREATE EXTENSION

Sekarang mari kita buat tabel pelanggan yang dipartisi berdasarkan tanggal terdaftar:

postgres=# CREATE TABLE customers (
  id INT NOT NULL,
  name VARCHAR(30) NOT NULL,
  registered DATE NOT NULL
)
PARTITION BY RANGE (registered);

Dan partisi berikut:

postgres=# CREATE TABLE customers_2021
    PARTITION OF customers
    FOR VALUES FROM ('2021-01-01') TO ('2022-01-01');
postgres=# CREATE TABLE customers_2020
    PARTITION OF customers
    FOR VALUES FROM ('2020-01-01') TO ('2021-01-01');

Partisi ini adalah lokal. Sekarang mari kita masukkan beberapa nilai pengujian dan memeriksanya:

postgres=# INSERT INTO customers (id, name, registered) VALUES (1, 'James', '2020-05-01');
postgres=# INSERT INTO customers (id, name, registered) VALUES (2, 'Mary', '2021-03-01');

Di sini Anda dapat menanyakan partisi utama untuk melihat semua data:

postgres=# SELECT * FROM customers;
 id | name  | registered
----+-------+------------
  1 | James | 2020-05-01
  2 | Mary  | 2021-03-01
(2 rows)

Atau bahkan menanyakan partisi yang sesuai:

postgres=# SELECT * FROM customers_2021;
 id | name | registered
----+------+------------
  2 | Mary | 2021-03-01
(1 row)

postgres=# SELECT * FROM customers_2020;
 id | name  | registered
----+-------+------------
  1 | James | 2020-05-01
(1 row)

Seperti yang Anda lihat, data dimasukkan ke dalam partisi yang berbeda, sesuai dengan tanggal yang didaftarkan. Sekarang, di node jarak jauh, dalam hal ini Shard2, mari buat tabel lain:

postgres=# CREATE TABLE customers_2019 (
    id INT NOT NULL,
    name VARCHAR(30) NOT NULL,
    registered DATE NOT NULL);

Anda perlu membuat server Shard2 ini di Shard1 dengan cara ini:

postgres=# CREATE SERVER shard2 FOREIGN DATA WRAPPER postgres_fdw OPTIONS (host '10.10.10.138', dbname 'postgres');

Dan pengguna untuk mengaksesnya:

postgres=# CREATE USER MAPPING FOR admindb SERVER shard2 OPTIONS (user 'admindb', password 'Passw0rd');

Sekarang, buat TABEL ASING di Shard1:

postgres=# CREATE FOREIGN TABLE customers_2019
PARTITION OF customers
FOR VALUES FROM ('2019-01-01') TO ('2020-01-01')
SERVER shard2;

Dan mari kita masukkan data ke tabel jarak jauh baru ini dari Shard1:

postgres=# INSERT INTO customers (id, name, registered) VALUES (3, 'Robert', '2019-07-01');
INSERT 0 1
postgres=# INSERT INTO customers (id, name, registered) VALUES (4, 'Jennifer', '2019-11-01');
INSERT 0 1

Jika semuanya berjalan dengan baik, Anda seharusnya dapat mengakses data dari Shard1 dan Shard2:

Shard1:

postgres=# SELECT * FROM customers;
 id |   name   | registered
----+----------+------------
  3 | Robert   | 2019-07-01
  4 | Jennifer | 2019-11-01
  1 | James    | 2020-05-01
  2 | Mary     | 2021-03-01
(4 rows)

postgres=# SELECT * FROM customers_2019;
 id |   name   | registered
----+----------+------------
  3 | Robert   | 2019-07-01
  4 | Jennifer | 2019-11-01
(2 rows)

Shard2:

postgres=# SELECT * FROM customers_2019;

 id |   name   | registered
----+----------+------------
  3 | Robert   | 2019-07-01
  4 | Jennifer | 2019-11-01
(2 rows)

Itu dia. Sekarang Anda menggunakan Sharding di Cluster PostgreSQL Anda.

Kesimpulan

Partisi dan Sharding di PostgreSQL adalah fitur yang bagus. Ini membantu Anda jika Anda perlu memisahkan data dalam tabel besar untuk meningkatkan kinerja, atau bahkan untuk membersihkan data dengan cara yang mudah, di antara situasi lainnya. Poin penting saat Anda menggunakan Sharding adalah memilih kunci shard yang bagus yang mendistribusikan data antar node dengan cara terbaik. Selain itu, Anda dapat menggunakan ClusterControl untuk menyederhanakan penerapan PostgreSQL dan memanfaatkan beberapa fitur seperti pemantauan, peringatan, failover otomatis, pencadangan, pemulihan tepat waktu, dan banyak lagi.