Menggunakan Sysbench untuk Menghasilkan Data Uji untuk Tabel Sharded di MySQL

Sysbench adalah alat yang hebat untuk menghasilkan data pengujian dan melakukan benchmark OLTP MySQL. Biasanya, seseorang akan melakukan siklus persiapan-jalan-pembersihan saat melakukan benchmark menggunakan Sysbench. Secara default, tabel yang dihasilkan oleh Sysbench adalah tabel dasar non-partisi standar. Perilaku ini dapat diperpanjang, tentu saja, tetapi Anda harus tahu cara menulisnya dalam skrip LUA.

Dalam posting blog ini, kami akan menunjukkan cara menghasilkan data uji untuk tabel yang dipartisi di MySQL menggunakan Sysbench. Ini dapat digunakan sebagai taman bermain bagi kita untuk menyelam lebih jauh ke dalam sebab-akibat dari partisi tabel, distribusi data, dan perutean kueri.

Partisi Tabel Server-tunggal

Partisi server tunggal berarti semua partisi tabel berada di server/instance MySQL yang sama. Saat membuat struktur tabel, kita akan mendefinisikan semua partisi sekaligus. Jenis partisi ini bagus jika Anda memiliki data yang kehilangan kegunaannya seiring waktu dan dapat dengan mudah dihapus dari tabel yang dipartisi dengan menghapus partisi (atau partisi) yang hanya berisi data tersebut.

Buat skema Sysbench:

mysql> CREATE SCHEMA sbtest;

Buat pengguna database sysbench:

mysql> CREATE USER 'sbtest'@'%' IDENTIFIED BY 'passw0rd';
mysql> GRANT ALL PRIVILEGES ON sbtest.* TO 'sbtest'@'%';

Di Sysbench, seseorang akan menggunakan perintah --prepare untuk menyiapkan server MySQL dengan struktur skema dan menghasilkan baris data. Kita harus melewati bagian ini dan mendefinisikan struktur tabel secara manual.

Buat tabel yang dipartisi. Dalam contoh ini, kita hanya akan membuat satu tabel bernama sbtest1 dan akan dipartisi oleh kolom bernama "k", yang pada dasarnya adalah bilangan bulat berkisar antara 0 hingga 1.000.000 (berdasarkan opsi --table-size yang kita gunakan akan digunakan dalam operasi penyisipan saja nanti):

mysql> CREATE TABLE `sbtest1` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `k` int(11) NOT NULL DEFAULT '0',
  `c` char(120) NOT NULL DEFAULT '',
  `pad` char(60) NOT NULL DEFAULT '',
  PRIMARY KEY (`id`,`k`)
  )
  PARTITION BY RANGE (k) (
    PARTITION p1 VALUES LESS THAN (499999),
    PARTITION p2 VALUES LESS THAN MAXVALUE
  );

Kita akan memiliki 2 partisi - Partisi pertama disebut p1 dan akan menyimpan data di mana nilai di kolom "k" lebih rendah dari 499.999 dan partisi kedua, p2, akan menyimpan nilai yang tersisa . Kami juga membuat kunci utama yang berisi kedua kolom penting - "id" untuk pengidentifikasi baris dan "k" adalah kunci partisi. Dalam mempartisi, kunci utama harus menyertakan semua kolom dalam fungsi partisi tabel (di mana kita menggunakan "k" dalam fungsi partisi rentang).

Verifikasi partisi yang ada:

mysql> SELECT TABLE_SCHEMA, TABLE_NAME, PARTITION_NAME, TABLE_ROWS 
       FROM INFORMATION_SCHEMA.PARTITIONS 
       WHERE TABLE_SCHEMA='sbtest2' 
       AND TABLE_NAME='sbtest1';
+--------------+------------+----------------+------------+
| TABLE_SCHEMA | TABLE_NAME | PARTITION_NAME | TABLE_ROWS |
+--------------+------------+----------------+------------+
| sbtest       | sbtest1    | p1             |          0 |
| sbtest       | sbtest1    | p2             |          0 |
+--------------+------------+----------------+------------+

Kami kemudian dapat memulai operasi penyisipan Sysbench saja seperti di bawah ini:

$ sysbench \
/usr/share/sysbench/oltp_insert.lua \
--report-interval=2 \
--threads=4 \
--rate=20 \
--time=9999 \
--db-driver=mysql \
--mysql-host=192.168.11.131 \
--mysql-port=3306 \
--mysql-user=sbtest \
--mysql-db=sbtest \
--mysql-password=passw0rd \
--tables=1 \
--table-size=1000000 \
run

Lihat partisi tabel tumbuh saat Sysbench berjalan:

mysql> SELECT TABLE_SCHEMA, TABLE_NAME, PARTITION_NAME, TABLE_ROWS 
       FROM INFORMATION_SCHEMA.PARTITIONS 
       WHERE TABLE_SCHEMA='sbtest2' 
       AND TABLE_NAME='sbtest1';
+--------------+------------+----------------+------------+
| TABLE_SCHEMA | TABLE_NAME | PARTITION_NAME | TABLE_ROWS |
+--------------+------------+----------------+------------+
| sbtest       | sbtest1    | p1             |       1021 |
| sbtest       | sbtest1    | p2             |       1644 |
+--------------+------------+----------------+------------+

Jika kita menghitung jumlah baris menggunakan fungsi COUNT, itu akan sesuai dengan jumlah baris yang dilaporkan oleh partisi:

mysql> SELECT COUNT(id) FROM sbtest1;
+-----------+
| count(id) |
+-----------+
|      2665 |
+-----------+

Itu dia. Kami telah menyiapkan partisi tabel server tunggal yang dapat kami mainkan.

Partisi Tabel Multi-server

Dalam partisi multi-server, kita akan menggunakan beberapa server MySQL untuk secara fisik menyimpan subset data dari tabel tertentu (sbtest1), seperti yang ditunjukkan pada diagram berikut:

Kita akan menerapkan 2 node MySQL independen - mysql1 dan mysql2. Tabel sbtest1 akan dipartisi pada dua node ini dan kita akan menyebut kombinasi partisi + host ini sebagai pecahan. Sysbench berjalan dari jarak jauh di server ketiga, meniru tingkat aplikasi. Karena Sysbench tidak mengetahui partisi, kita perlu memiliki driver database atau router untuk merutekan kueri database ke shard yang tepat. Kami akan menggunakan ProxySQL untuk mencapai tujuan ini.

Mari kita buat database baru bernama sbtest3 untuk tujuan ini:

mysql> CREATE SCHEMA sbtest3;
mysql> USE sbtest3;

Berikan hak istimewa yang tepat kepada pengguna database sbtest:

mysql> CREATE USER 'sbtest'@'%' IDENTIFIED BY 'passw0rd';
mysql> GRANT ALL PRIVILEGES ON sbtest3.* TO 'sbtest'@'%';

Di mysql1, buat partisi pertama dari tabel:

mysql> CREATE TABLE `sbtest1` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `k` int(11) NOT NULL DEFAULT '0',
  `c` char(120) NOT NULL DEFAULT '',
  `pad` char(60) NOT NULL DEFAULT '',
  PRIMARY KEY (`id`,`k`)
  )
  PARTITION BY RANGE (k) (
    PARTITION p1 VALUES LESS THAN (499999)
  );

Tidak seperti partisi mandiri, kami hanya mendefinisikan kondisi untuk partisi p1 dalam tabel untuk menyimpan semua baris dengan nilai kolom "k" mulai dari 0 hingga 499.999.

Di mysql2, buat tabel lain yang dipartisi:

mysql> CREATE TABLE `sbtest1` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `k` int(11) NOT NULL DEFAULT '0',
  `c` char(120) NOT NULL DEFAULT '',
  `pad` char(60) NOT NULL DEFAULT '',
  PRIMARY KEY (`id`,`k`)
  )
  PARTITION BY RANGE (k) (
    PARTITION p2 VALUES LESS THAN MAXVALUE
  );

Pada server kedua, ia harus menyimpan data dari partisi kedua dengan menyimpan sisa nilai yang diantisipasi dari kolom "k".

Struktur tabel kami sekarang siap diisi dengan data uji.

Sebelum kita dapat menjalankan operasi insert-only Sysbench, kita perlu menginstal server ProxySQL sebagai router kueri dan bertindak sebagai gateway untuk shard MySQL kita. Sharding multi-server memerlukan koneksi database yang berasal dari aplikasi untuk dirutekan ke shard yang benar. Jika tidak, Anda akan melihat kesalahan berikut:

1526 (Table has no partition for value 503599)

Instal ProxySQL menggunakan ClusterControl, tambahkan pengguna database sbtest ke ProxySQL, tambahkan kedua server MySQL ke dalam ProxySQL dan konfigurasikan mysql1 sebagai hostgroup 11 dan mysql2 sebagai hostgroup 12:

Selanjutnya, kita perlu mengerjakan bagaimana kueri harus diarahkan. Contoh kueri INSERT yang akan dilakukan oleh Sysbench akan terlihat seperti ini:

INSERT INTO sbtest1 (id, k, c, pad) 
  VALUES (0, 503502, '88816935247-23939908973-66486617366-05744537902-39238746973-63226063145-55370375476-52424898049-93208870738-99260097520', '36669559817-75903498871-26800752374-15613997245-76119597989')

Jadi kita akan menggunakan ekspresi reguler berikut untuk memfilter kueri INSERT untuk "k" => 500000, untuk memenuhi kondisi partisi:

^INSERT INTO sbtest1 \(id, k, c, pad\) VALUES \([0-9]\d*, ([5-9]{1,}[0-9]{5}|[1-9]{1,}[0-9]{6,}).*

Ekspresi di atas hanya mencoba memfilter berikut ini:

[0-9]\d* - Kami mengharapkan bilangan bulat peningkatan otomatis di sini, oleh karena itu, kami mencocokkan dengan bilangan bulat apa pun.
[5-9]{1,}[0-9]{5} - Nilainya cocok dengan bilangan bulat apa pun dari 5 sebagai digit pertama, dan 0-9 pada 5 digit terakhir, untuk mencocokkan nilai rentang dari 500.000 hingga 999.999.

[1-9]{1,}[0-9]{6,} - Nilainya cocok dengan bilangan bulat apa pun dari 1-9 sebagai digit pertama, dan 0-9 pada 6 digit terakhir atau lebih besar, untuk mencocokkan nilai dari 1.000.000 dan lebih besar.

Kami akan membuat dua aturan kueri yang serupa. Aturan kueri pertama adalah negasi dari ekspresi reguler di atas. Kami memberikan ID aturan ini 51 dan grup host tujuan harus grup host 11 untuk mencocokkan kolom "k" <500.000 dan meneruskan kueri ke partisi pertama. Seharusnya terlihat seperti ini:

Perhatikan "Pola Pencocokan Negasi" pada tangkapan layar di atas. Opsi tersebut sangat penting untuk perutean yang tepat dari aturan kueri ini.

Selanjutnya, buat aturan kueri lain dengan ID aturan 52, menggunakan ekspresi reguler yang sama dan grup host tujuan harus 12, tetapi kali ini, biarkan "Pola Pencocokan Negasi" sebagai salah, seperti yang ditunjukkan di bawah ini:

Kemudian kita dapat memulai operasi penyisipan saja menggunakan Sysbench untuk menghasilkan data uji . Informasi terkait akses MySQL harus menjadi host ProxySQL (192.168.11.130 pada port 6033):

$ sysbench \ /usr/share/sysbench/oltp_insert.lua \ --report-interval=2 \ --threads=4 \ --rate=20 \ --time=9999 \ --db-driver=mysql \ --mysql-host=192.168.11.130 \ --mysql-port=6033 \ --mysql-user=sbtest \ --mysql-db=sbtest3 \ --mysql-password=passw0rd \ --tables=1 \ --table-size=1000000 \ run

Jika Anda tidak melihat kesalahan apa pun, itu berarti ProxySQL telah mengarahkan kueri kami ke pecahan/partisi yang benar. Anda akan melihat klik aturan kueri meningkat saat proses Sysbench sedang berjalan:

Di bawah bagian Kueri Teratas, kita dapat melihat ringkasan perutean kueri:

Untuk mengecek ulang, login ke mysql1 untuk mencari partisi pertama dan periksa nilai minimum dan maksimum kolom 'k' pada tabel sbtest1:

mysql> USE sbtest3; mysql> SELECT min(k), max(k) FROM sbtest1; +--------+--------+ | min(k) | max(k) | +--------+--------+ | 232185 | 499998 | +--------+--------+

Terlihat bagus. Nilai maksimum kolom "k" tidak melebihi batas 499.999. Mari kita periksa jumlah baris yang disimpan untuk partisi ini:

mysql> SELECT TABLE_SCHEMA, TABLE_NAME, PARTITION_NAME, TABLE_ROWS FROM INFORMATION_SCHEMA.PARTITIONS WHERE TABLE_SCHEMA='sbtest3' AND TABLE_NAME='sbtest1'; +--------------+------------+----------------+------------+ | TABLE_SCHEMA | TABLE_NAME | PARTITION_NAME | TABLE_ROWS | +--------------+------------+----------------+------------+ | sbtest3 | sbtest1 | p1 | 1815 | +--------------+------------+----------------+------------+

Sekarang mari kita periksa server MySQL lainnya (mysql2):

mysql> USE sbtest3; mysql> SELECT min(k), max(k) FROM sbtest1; +--------+--------+ | min(k) | max(k) | +--------+--------+ | 500003 | 794952 | +--------+--------+

Mari kita periksa jumlah baris yang disimpan untuk partisi ini:

mysql> SELECT TABLE_SCHEMA, TABLE_NAME, PARTITION_NAME, TABLE_ROWS FROM INFORMATION_SCHEMA.PARTITIONS WHERE TABLE_SCHEMA='sbtest3' AND TABLE_NAME='sbtest1'; +--------------+------------+----------------+------------+ | TABLE_SCHEMA | TABLE_NAME | PARTITION_NAME | TABLE_ROWS | +--------------+------------+----------------+------------+ | sbtest3 | sbtest1 | p2 | 3247 | +--------------+------------+----------------+------------+

Hebat! Kami memiliki pengaturan pengujian MySQL sharded dengan partisi data yang tepat menggunakan Sysbench untuk kami mainkan. Selamat membuat tolok ukur!