Cara Membandingkan Kinerja PostgreSQL Menggunakan Sysbench

Benchmarking adalah cara untuk mengetahui kinerja infrastruktur Anda. Sysbench adalah alat yang hebat untuk benchmark server PostgreSQL. Dalam posting blog ini, kami akan menunjukkan cara menghasilkan beban uji menggunakan sysbench. Kami akan menggunakan pengaturan replikasi streaming master-slave dua node oleh ClusterControl. Ini juga akan membantu kami menghasilkan beberapa aktivitas di cluster, dan memeriksa apakah replikasi berfungsi seperti yang diharapkan.

Kami akan menginstal sysbench versi terbaru, yang saat ini dipertahankan di sini. Kami akan menggunakan paket yang lebih diperbarui yang disediakan di halaman Github resmi untuk menginstal sysbench. Kami juga akan menggunakan biner PostgreSQL 9.6 standar dari halaman unduhan PostgreSQL. Perhatikan bahwa jalur yang digunakan dalam posting blog ini mungkin berbeda tergantung pada versi PostgreSQL dan vendor yang telah Anda instal.

Sebagai catatan tambahan, kami telah membahas posting blog serupa tentang benchmarking PostgreSQL menggunakan pgbench di posting blog ini, Cara Membandingkan Kinerja PostgreSQL.

Menginstal Sysbench

Menginstal sysbench itu mudah. Untuk Debian/Ubuntu:

$ curl -s https://packagecloud.io/install/repositories/akopytov/sysbench/script.deb.sh | sudo bash
$ sudo apt -y install sysbench

Dan untuk RHEL/CentOS:

$ curl -s https://packagecloud.io/install/repositories/akopytov/sysbench/script.rpm.sh | sudo bash
$ sudo yum -y install sysbench

Instal paket sysbench:

$ yum install sysbench

Verifikasi versi:

$ sysbench --version
sysbench 1.0.15

Kami sekarang telah menginstal sysbench.

Menginisialisasi Data Uji

Jika Anda terbiasa dengan sysbench, ia menggunakan default berikut untuk parameter PostgreSQL:

pgsql-host=localhost
pgsql-port=5432
pgsql-user=sbtest
pgsql-password=sandi
pgsql-db=sbtest

Pertama, buat database dan pengguna di dalam PostgreSQL:

$ su - postgres
$ psql
> CREATE USER sbtest WITH PASSWORD 'password';
> CREATE DATABASE sbtest;
> GRANT ALL PRIVILEGES ON DATABASE sbtest TO sbtest;

Kemudian edit file akses berbasis host, pg_hba.conf :

$ vim /var/lib/pgsql/9.6/data/pg_hba.conf

Dan tambahkan baris berikut untuk mengizinkan koneksi untuk sbtest pengguna, ke database sbtest dari semua host di bawah jaringan 192.168.55.0:

host    sbtest          sbtest          192.168.55.0/24         md5

Muat ulang server untuk menerapkan perubahan:

$ /usr/pgsql-9.6/bin/pg_ctl --reload

Verifikasi dari klien baris perintah psql jika otentikasi pengguna berfungsi dengan benar:

$ psql -U sbtest -h 192.168.55.61 -p 5432 -d sbtest -W

Anda harus bisa masuk ke server di bawah database sbtest:

$ psql -U sbtest -h 192.168.55.61 -p 5432 -W
Password for user sbtest:
Type "help" for help.

sbtest=>

Jalankan "\q" untuk keluar dari terminal. Kita sekarang dapat menginisialisasi database menggunakan sysbench dengan perintah berikut:

$ sysbench \
--db-driver=pgsql \
--oltp-table-size=100000 \
--oltp-tables-count=24 \
--threads=1 \
--pgsql-host=192.168.55.61 \
--pgsql-port=5432 \
--pgsql-user=sbtest \
--pgsql-password=password \
--pgsql-db=sbtest \
/usr/share/sysbench/tests/include/oltp_legacy/parallel_prepare.lua \
run

Perintah di atas menghasilkan 100.000 baris per tabel untuk 24 tabel (sbtest1 hingga sbtest24) di dalam database 'sbtest'. Nama skema adalah "publik" yang merupakan default. Data disiapkan oleh skrip yang disebut parallel_prepare.lua yang tersedia di /usr/share/sysbench/tests/include/oltp_legacy.

Verifikasi tabel yang dihasilkan dengan perintah berikut:

$ psql -U sbtest -h 192.168.55.61 -p 5432 -W -c '\dt+\'
Password for user sbtest:
                    List of relations
 Schema |   Name   | Type  | Owner  | Size  | Description
--------+----------+-------+--------+-------+-------------
 public | sbtest1  | table | sbtest | 21 MB |
 public | sbtest10 | table | sbtest | 21 MB |
 public | sbtest11 | table | sbtest | 21 MB |
 public | sbtest12 | table | sbtest | 21 MB |
 public | sbtest13 | table | sbtest | 21 MB |
 public | sbtest14 | table | sbtest | 21 MB |
 public | sbtest15 | table | sbtest | 21 MB |
 public | sbtest16 | table | sbtest | 21 MB |
 public | sbtest17 | table | sbtest | 21 MB |
 public | sbtest18 | table | sbtest | 21 MB |
 public | sbtest19 | table | sbtest | 21 MB |
 public | sbtest2  | table | sbtest | 21 MB |
 public | sbtest20 | table | sbtest | 21 MB |
 public | sbtest21 | table | sbtest | 21 MB |
 public | sbtest22 | table | sbtest | 21 MB |
 public | sbtest23 | table | sbtest | 21 MB |
 public | sbtest24 | table | sbtest | 21 MB |
 public | sbtest3  | table | sbtest | 21 MB |
 public | sbtest4  | table | sbtest | 21 MB |
 public | sbtest5  | table | sbtest | 21 MB |
 public | sbtest6  | table | sbtest | 21 MB |
 public | sbtest7  | table | sbtest | 21 MB |
 public | sbtest8  | table | sbtest | 21 MB |
 public | sbtest9  | table | sbtest | 21 MB |
(24 rows)

Data pengujian sekarang dimuat.

Unduh Whitepaper Hari Ini Pengelolaan &Otomatisasi PostgreSQL dengan ClusterControlPelajari tentang apa yang perlu Anda ketahui untuk menerapkan, memantau, mengelola, dan menskalakan PostgreSQLUnduh Whitepaper

Hasilkan Beban Uji

Ada berbagai jenis beban kerja database yang dapat Anda lakukan dengan sysbench, seperti yang ditunjukkan di bagian berikut.

Baca/Tulis Muat

Perintahnya mirip dengan sysbench versi MySQL. Parameter serupa dapat digunakan kecuali parameter terkait PostgreSQL:

$ sysbench \
--db-driver=pgsql \
--report-interval=2 \
--oltp-table-size=100000 \
--oltp-tables-count=24 \
--threads=64 \
--time=60 \
--pgsql-host=192.168.55.61 \
--pgsql-port=5432 \
--pgsql-user=sbtest \
--pgsql-password=password \
--pgsql-db=sbtest \
/usr/share/sysbench/tests/include/oltp_legacy/oltp.lua \
run

Perintah di atas akan menghasilkan beban kerja OLTP dari skrip LUA yang disebut /usr/share/sysbench/tests/include/oltp_legacy/oltp.lua, terhadap 100.000 baris dari 24 tabel dengan 64 thread pekerja selama 60 detik di host 192.168.55.61 (master ). Setiap 2 detik, sysbench akan melaporkan statistik perantara (--report-interval=2 ).

Setelah dieksekusi, Anda akan mendapatkan sesuatu seperti di bawah ini:

sysbench 1.0.15 (using bundled LuaJIT 2.1.0-beta2)

Running the test with following options:
Number of threads: 16
Report intermediate results every 2 second(s)
Initializing random number generator from current time

Initializing worker threads...

Threads started!

[ 2s ] thds: 64 tps: 0.00 qps: 466.69 (r/w/o: 406.55/28.33/31.81) lat (ms,95%): 0.00 err/s: 0.00 reconn/s: 0.00
[ 4s ] thds: 64 tps: 30.55 qps: 525.38 (r/w/o: 335.56/128.72/61.10) lat (ms,95%): 3639.94 err/s: 0.00 reconn/s: 0.00
[ 6s ] thds: 64 tps: 39.55 qps: 718.41 (r/w/o: 496.13/142.68/79.60) lat (ms,95%): 4128.91 err/s: 0.00 reconn/s: 0.00
[ 8s ] thds: 64 tps: 35.98 qps: 840.95 (r/w/o: 604.11/163.89/72.95) lat (ms,95%): 2198.52 err/s: 0.50 reconn/s: 0.00
[ 10s ] thds: 64 tps: 65.57 qps: 1314.94 (r/w/o: 912.00/271.80/131.14) lat (ms,95%): 3040.14 err/s: 0.00 reconn/s: 0.00
...

Saat pengujian sedang berlangsung, kami dapat memantau aktivitas PostgreSQL menggunakan pg_activity atau pg_top , untuk mengkonfirmasi statistik perantara yang dilaporkan oleh sysbench. Di terminal lain, lakukan:

$ su - postgres
$ pg_activity
 PostgreSQL 9.6.9 - postgres1.local - [email protected]:5432/postgres - Ref.: 2s
  Size:  654.62M -     7.67K/s        | TPS:          74
  Mem.:   39.10% -   382.72M/979.68M  | IO Max:     3395/s
  Swap:    0.20% -     3.57M/2.00G    | Read :      8.36M/s -   2141/s
  Load:    20.20 6.02 2.44            | Write:      2.54M/s -    650/s
                                                                   RUNNING QUERIES
PID    DATABASE              USER           CLIENT   CPU% MEM%   READ/s  WRITE/s     TIME+  W  IOW              state   Query
5130   sbtest              sbtest    192.168.55.61    1.0  2.8  791.57K    3.84K  0.788732  N    N             active   SELECT c FROM sbtest7 WHERE id BETWEEN 33195
 AND 33294
...

Serta aliran replikasi dengan melihat pg_stat_replication tabel di server master:

$ su - postgres
$ watch -n1 'psql -xc "select * from pg_stat_replication"'
Every 1.0s: psql -xc "select * from pg_stat_replication"      Tue Jul 31 13:12:08 2018
-[ RECORD 1 ]----+------------------------------
pid              | 3792
usesysid         | 16448
usename          | slave
application_name | walreceiver
client_addr      | 192.168.55.62
client_hostname  |
client_port      | 44654
backend_start    | 2018-07-30 13:41:41.707514+08
backend_xmin     |
state            | streaming
sent_location    | 0/60933D78
write_location   | 0/60933D78
flush_location   | 0/60933D78
replay_location  | 0/60933D78
sync_priority    | 0
sync_state       | async

Perintah "watch" di atas menjalankan perintah psql setiap 1 detik. Anda akan melihat kolom "*_location" diperbarui sesuai saat replikasi terjadi.

Di akhir tes, Anda akan melihat ringkasannya:

SQL statistics:
    queries performed:
        read:                            67704
        write:                           19322
        other:                           9682
        total:                           96708
    transactions:                        4830   (79.34 per sec.)
    queries:                             96708  (1588.53 per sec.)
    ignored errors:                      6      (0.10 per sec.)
    reconnects:                          0      (0.00 per sec.)

General statistics:
    total time:                          60.8723s
    total number of events:              4830

Latency (ms):
         min:                                    4.52
         avg:                                  799.70
         max:                                 8082.70
         95th percentile:                     2279.14
         sum:                              3862532.62

Threads fairness:
    events (avg/stddev):           75.4688/7.39
    execution time (avg/stddev):   60.3521/0.20

Ringkasan di atas memberi tahu kita bahwa server database PostgreSQL kami dapat menangani rata-rata sekitar 80 transaksi per detik dan sekitar 1588 kueri per detik di bawah 64 utas pekerja.

Muat Hanya Baca

Untuk pengujian hanya baca, Anda dapat menggunakan perintah yang sama, tetapi ubah skrip LUA menjadi select.lua , select_random_points.lua , select_random_ranges.lua atau oltp_simple.lua :

$ sysbench \
--db-driver=pgsql \
--report-interval=2 \
--oltp-table-size=100000 \
--oltp-tables-count=24 \
--threads=64 \
--time=60 \
--pgsql-host=192.168.55.62 \
--pgsql-port=5432 \
--pgsql-user=sbtest \
--pgsql-password=password \
--pgsql-db=sbtest \
/usr/share/sysbench/tests/include/oltp_legacy/select.lua \
run

Perintah di atas menjalankan beban kerja read-only yang disebut select.lua terhadap server budak PostgreSQL (replikasi streaming), 192.168.55.62 dengan 64 utas pekerja.

Beban Lainnya

Ada banyak beban kerja OLTP lain yang dapat Anda hasilkan dengan sysbench, seperti yang tercantum di bawah direktori ini, /usr/share/sysbench/tests/include/oltp_legacy :

$ ls -1 /usr/share/sysbench/tests/include/oltp_legacy/
bulk_insert.lua
common.lua
delete.lua
insert.lua
oltp.lua
oltp_simple.lua
parallel_prepare.lua
select.lua
select_random_points.lua
select_random_ranges.lua
update_index.lua
update_non_index.lua

Anda dapat menggunakan perintah serupa dan mengubah jalur ke skrip LUA untuk memuatnya.

Pemikiran Akhir

Menggunakan sysbench, kami dapat menghasilkan beban uji untuk server PostgreSQL kami (serta untuk MySQL). Perhatikan bahwa tolok ukur terbaik adalah dengan data dan aplikasi Anda yang sebenarnya, tetapi itu mungkin tidak selalu memungkinkan. Bisa juga aplikasi baru yang akan cepat berkembang. Meskipun beban yang dihasilkan oleh sysbench mungkin tidak menggambarkan beban kerja OLTP dunia nyata Anda, itu mungkin cukup baik.