Sådan benchmarker du PostgreSQL-ydelse ved hjælp af Sysbench

Benchmarking er en måde at opdage din infrastrukturs ydeevne på. Sysbench er et fantastisk værktøj til at benchmarke PostgreSQL-servere. I dette blogindlæg viser vi dig, hvordan du genererer testbelastninger ved hjælp af sysbench. Vi vil gøre brug af en to-node master-slave streaming-replikeringsopsætning af ClusterControl. Dette vil også hjælpe os med at generere noget aktivitet på klyngen og kontrollere, at replikering fungerer som forventet.

Vi installerer den seneste version af sysbench, som i øjeblikket vedligeholdes her. Vi bruger den mere opdaterede pakke på den officielle Github-side til at installere sysbench. Vi vil også bruge standard PostgreSQL 9.6-binære filer fra PostgreSQL-downloadsiden. Vær opmærksom på, at stien, der bruges i dette blogindlæg, kan være anderledes afhængigt af PostgreSQL-versionen og leverandøren, du har installeret.

Som en sidebemærkning har vi dækket et lignende blogindlæg om benchmarking af PostgreSQL ved hjælp af pgbench i dette blogindlæg, How to Benchmark PostgreSQL Performance.

Installation af Sysbench

Det er nemt at installere sysbench. Til Debian/Ubuntu:

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

Og for RHEL/CentOS:

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

Installer sysbench-pakken:

$ yum install sysbench

Bekræft versionen:

$ sysbench --version
sysbench 1.0.15

Vi har nu installeret sysbench.

Initialisering af testdata

Hvis du er bekendt med sysbench, bruger den følgende standardindstillinger for PostgreSQL-parametre:

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

Først skal du oprette databasen og brugeren inde i PostgreSQL:

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

Rediger derefter den værtsbaserede adgangsfil, pg_hba.conf :

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

Og tilføj følgende linje for at tillade forbindelser for bruger sbtest, til database sbtest fra alle værter under 192.168.55.0 netværk:

host    sbtest          sbtest          192.168.55.0/24         md5

Genindlæs serveren for at anvende ændringerne:

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

Bekræft fra psql-kommandolinjeklienten, om brugergodkendelsen fungerer korrekt:

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

Du burde være i stand til at komme ind på serveren under sbtest database:

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

sbtest=>

Kør "\q" for at afslutte terminalen. Vi kan nu initialisere databasen ved hjælp af sysbench med følgende kommando:

$ 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

Ovenstående kommando genererer 100.000 rækker pr. tabel til 24 tabeller (sbtest1 til sbtest24) inde i databasen 'sbtest'. Skemanavnet er "offentlig", hvilket er standard. Dataene er udarbejdet af et script kaldet parallel_prepare.lua som er tilgængelig under /usr/share/sysbench/tests/include/oltp_legacy.

Bekræft de genererede tabeller med følgende kommando:

$ 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)

Testdataene er nu indlæst.

Download Whitepaper Today PostgreSQL Management &Automation med ClusterControlFå flere oplysninger om, hvad du skal vide for at implementere, overvåge, administrere og skalere PostgreSQLDownload Whitepaper

Generer testbelastninger

Der er forskellige slags databasearbejdsbelastninger, du kan udføre med sysbench, som vist i de følgende afsnit.

Læse/Skrive Load

Kommandoen ligner MySQL's version af sysbench. Lignende parametre kan bruges undtagen PostgreSQL-relaterede parametre:

$ 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

Ovenstående kommando vil generere OLTP-arbejdsbelastningen fra LUA-scriptet kaldet /usr/share/sysbench/tests/include/oltp_legacy/oltp.lua, mod 100.000 rækker af 24 tabeller med 64 arbejdstråde i 60 sekunder på vært 192.168.55.61. ). Hvert andet sekund vil sysbench rapportere den mellemliggende statistik (--report-interval=2 ).

Når den er udført, vil du få noget som nedenfor:

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
...

Når testen var i gang, kan vi overvåge PostgreSQL-aktiviteten ved hjælp af pg_activity eller pg_top , for at bekræfte den mellemliggende statistik rapporteret af sysbench. I en anden terminal skal du gøre:

$ 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
...

Samt replikeringsstrømmen ved at se på pg_stat_replication tabel på masterserveren:

$ 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

Ovenstående "watch"-kommando kører psql-kommandoen hvert 1. sekund. Du bør se "*_location"-kolonner opdateres i overensstemmelse hermed, når replikering sker.

I slutningen af testen skal du se resuméet:

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

Ovenstående oversigt fortæller os, at vores PostgreSQL-databaseserver i gennemsnit kan håndtere omkring 80 transaktioner pr. sekund og omkring 1588 forespørgsler pr. sekund under 64 arbejdstråde.

Skrivebeskyttet indlæsning

Til skrivebeskyttet test kan du bruge den samme kommando, men ændre LUA-scriptet til select.lua , select_random_points.lua , select_random_ranges.lua eller 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

Ovenstående kommando kører en skrivebeskyttet arbejdsbelastning kaldet select.lua mod en PostgreSQL-slaveserver (streaming-replikering), 192.168.55.62 med 64 arbejdertråde.

Andre belastninger

Der er mange andre OLTP-arbejdsbelastninger, som du kan generere med sysbench, som angivet under denne mappe, /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

Du kan bruge den lignende kommando og ændre stien til LUA-scriptet for at indlæse det.

Sidste tanker

Ved hjælp af sysbench kan vi generere testbelastninger til vores PostgreSQL-server (såvel som til MySQL). Bemærk, at det bedste benchmark ville være med dine rigtige data og applikationer, men det er måske ikke altid muligt. Det kan også være en ny applikation, der hurtigt vil udvikle sig. På trods af den belastning, der genereres af sysbench, måske ikke afbilder din OLTP-arbejdsbelastning i den virkelige verden, er den måske lige god nok.