sql >> Databasteknik >  >> RDS >> PostgreSQL

Hur man benchmarkar PostgreSQL-prestanda med Sysbench

Benchmarking är ett sätt att upptäcka prestandan hos din infrastruktur. Sysbench är ett utmärkt verktyg för att benchmarka PostgreSQL-servrar. I det här blogginlägget visar vi dig hur du genererar testbelastningar med sysbench. Vi kommer att använda en tvånods master-slav streaming-replikeringsuppsättning av ClusterControl. Detta kommer också att hjälpa oss att generera viss aktivitet i klustret och kontrollera att replikeringen fungerar som förväntat.

Vi kommer att installera den senaste versionen av sysbench, som för närvarande underhålls här. Vi kommer att använda det mer uppdaterade paketet som finns på den officiella Github-sidan för att installera sysbench. Vi kommer också att använda standard PostgreSQL 9.6-binärfiler från PostgreSQL-nedladdningssidan. Observera att sökvägen som används i det här blogginlägget kan vara annorlunda beroende på vilken PostgreSQL-version och leverantör du har installerat.

Som en sidoanteckning har vi tagit upp ett liknande blogginlägg om benchmarking av PostgreSQL med pgbench i det här blogginlägget, How to Benchmark PostgreSQL Performance.

Installera Sysbench

Det är enkelt att installera sysbench. För Debian/Ubuntu:

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

Och för RHEL/CentOS:

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

Installera sysbench-paketet:

$ yum install sysbench

Verifiera versionen:

$ sysbench --version
sysbench 1.0.15

Vi har nu installerat sysbench.

Initiering av testdata

Om du är bekant med sysbench använder den följande standardinställningar för PostgreSQL-parametrar:

  • pgsql-host=localhost
  • pgsql-port=5432
  • pgsql-user=sbtest
  • pgsql-password=lösenord
  • pgsql-db=sbtest

Skapa först databasen och användaren i PostgreSQL:

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

Redigera sedan den värdbaserade åtkomstfilen, pg_hba.conf :

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

Och lägg till följande rad för att tillåta anslutningar för användaren sbtest, till databasen sbtest från alla värdar under nätverket 192.168.55.0:

host    sbtest          sbtest          192.168.55.0/24         md5

Ladda om servern för att tillämpa ändringarna:

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

Verifiera från psql kommandoradsklient om användarautentiseringen fungerar korrekt:

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

Du bör kunna komma in på servern under sbtest-databasen:

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

sbtest=>

Kör "\q" för att avsluta från terminalen. Vi kan nu initiera databasen med sysbench med följande 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

Ovanstående kommando genererar 100 000 rader per tabell för 24 tabeller (sbtest1 till sbtest24) inuti databasen 'sbtest'. Schematnamnet är "public" vilket är standard. Data förbereds av ett skript som heter parallel_prepare.lua som är tillgängligt under /usr/share/sysbench/tests/include/oltp_legacy.

Verifiera de genererade tabellerna med följande 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)

Testdatan är nu laddad.

Ladda ner Whitepaper Today PostgreSQL Management &Automation med ClusterControlLäs om vad du behöver veta för att distribuera, övervaka, hantera och skala PostgreSQLDladda Whitepaper

Generera testbelastningar

Det finns olika typer av databasarbetsbelastningar du kan utföra med sysbench, som visas i följande avsnitt.

Läs/skrivladdning

Kommandot liknar MySQL:s version av sysbench. Liknande parametrar kan användas förutom PostgreSQL-relaterade parametrar:

$ 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

Kommandot ovan kommer att generera OLTP-arbetsbelastningen från LUA-skriptet som heter /usr/share/sysbench/tests/include/oltp_legacy/oltp.lua, mot 100 000 rader med 24 tabeller med 64 arbetstrådar i 60 sekunder på värd 192.168.55.61. ). Varannan sekund kommer sysbench att rapportera den mellanliggande statistiken (--report-interval=2 ).

När den väl har körts får du något i stil med nedan:

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 testet pågick kan vi övervaka PostgreSQL-aktiviteten med pg_activity eller pg_top , för att bekräfta den mellanliggande statistiken som rapporterats av sysbench. I en annan terminal gör du:

$ 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 genom att titta på pg_stat_replication tabell på huvudservern:

$ 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

Ovanstående "watch"-kommando kör kommandot psql var 1:e sekund. Du bör se "*_location"-kolumner uppdateras i enlighet med detta när replikering sker.

I slutet av testet bör du se sammanfattningen:

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

Sammanfattningen ovan berättar för oss att vår PostgreSQL-databasserver i genomsnitt kan hantera cirka 80 transaktioner per sekund och cirka 1588 frågor per sekund under 64 arbetartrådar.

Skrivskyddad laddning

För skrivskyddat test kan du använda samma kommando, men ändra LUA-skriptet till 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

Ovanstående kommando kör en skrivskyddad arbetsbelastning som heter select.lua mot en PostgreSQL-slavserver (strömmande replikering), 192.168.55.62 med 64 arbetartrådar.

Andra laster

Det finns många andra OLTP-arbetsbelastningar som du kan generera med sysbench, som listas under den här katalogen, /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 använda liknande kommando och ändra sökvägen till LUA-skriptet för att ladda upp det.

Sluta tankar

Med sysbench kan vi generera testbelastningar för vår PostgreSQL-server (liksom för MySQL). Observera att det bästa riktmärket skulle vara med dina riktiga data och applikationer, men det kanske inte alltid är möjligt. Det kan också vara en ny applikation som snabbt kommer att utvecklas. Trots belastningen som genereras av sysbench kanske inte avbildar din verkliga OLTP-arbetsbelastning, kan den vara precis tillräckligt bra.


  1. SQLite och databasinitiering

  2. Skapa en dynamisk mysql-fråga med php-variabler

  3. Dynamisk uppdateringssats med variabla kolumnnamn

  4. Hur man rundar upp ett tal till närmaste heltal i SQL