A PostgreSQL optimális teljesítménye az operációs rendszer helyesen meghatározott paramétereitől függ. A rosszul konfigurált operációs rendszer kernelbeállításai az adatbázis-kiszolgáló gyenge teljesítményét eredményezhetik. Ezért elengedhetetlen, hogy ezeket a beállításokat az adatbázis-kiszolgálónak és annak munkaterhelésének megfelelően konfigurálják. Ebben a bejegyzésben megvitatunk néhány fontos Linux kernelparamétert, amelyek befolyásolhatják az adatbázis-kiszolgáló teljesítményét, és hogyan kell konfigurálni őket.
SHMMAX / SHMALL
SHMMAX egy kernelparaméter, amellyel meghatározható egy Linux-folyamat által lefoglalható egyetlen megosztott memória szegmens maximális mérete. A 9.2-es verzió előtt a PostgreSQL System V-t (SysV) használt, amelyhez az SHMMAX beállítás szükséges. A 9.2 után a PostgreSQL POSIX megosztott memóriára váltott. Így most kevesebb bájt System V megosztott memóriára van szükség.
A 9.3-as verzió előtt az SHMMAX volt a legfontosabb kernelparaméter. Az SHMMAX érték bájtokban van megadva.
Hasonlóképpen, SHMALL egy másik kernelparaméter, amelyet a meghatározására használnak
rendszerszintű megosztott memória oldalak mennyisége. Az aktuális SHMMAX, SHMALL vagy SHMMIN értékek megtekintéséhez használja a parancsot ipcs.
SHM* Részletek - Linux
$ ipcs -lm
------ Shared Memory Limits --------
max number of segments = 4096
max seg size (kbytes) = 1073741824
max total shared memory (kbytes) = 17179869184
min seg size (bytes) = 1SHM* Részletek – MacOS X
$ ipcs -M
IPC status from as of Thu Aug 16 22:20:35 PKT 2018
shminfo:
shmmax: 16777216 (max shared memory segment size)
shmmin: 1 (min shared memory segment size)
shmmni: 32 (max number of shared memory identifiers)
shmseg: 8 (max shared memory segments per process)
shmall: 1024 (max amount of shared memory in pages)
PostgreSQL használ V rendszer IPC megosztott memória lefoglalásához. Ez a paraméter az egyik legfontosabb kernelparaméter. Amikor a következő hibaüzeneteket kapja, az azt jelenti, hogy a PostgreSQL régebbi verziója van, és az SHMMAX értéke nagyon alacsony. A felhasználóktól elvárják, hogy a használni kívánt megosztott memóriának megfelelően állítsák be és növeljék az értéket.
Lehetséges hibás konfigurációs hibák
Ha az SHMMAX nincs megfelelően konfigurálva, hibaüzenetet kaphat, amikor megpróbál inicializálni egy PostgreSQL-fürtöt a paranccsal initdb.
initdb hiba
DETAIL: Failed system call was shmget(key=1, size=2072576, 03600).
HINT: This error usually means that PostgreSQL's request for a shared memory segment exceeded your kernel's SHMMAX parameter.
You can either reduce the request size or reconfigure the kernel with larger SHMMAX. To reduce the request size (currently 2072576 bytes),
reduce PostgreSQL's shared memory usage, perhaps by reducing shared_buffers or max_connections.
If the request size is already small, it's possible that it is less than your kernel's SHMMIN parameter,
in which case raising the request size or reconfiguring SHMMIN is called for.
The PostgreSQL documentation contains more information about shared memory configuration. child process exited with exit code 1
Hasonlóképpen hibaüzenetet kaphat, amikor elindítja a PostgreSQL-kiszolgálót a parancs használatával pg_ctl.
pg_ctl Hiba
DETAIL: Failed system call was shmget(key=5432001, size=14385152, 03600).
HINT: This error usually means that PostgreSQL's request for a shared memory segment exceeded your kernel's SHMMAX parameter.
You can either reduce the request size or reconfigure the kernel with larger SHMMAX.; To reduce the request size (currently 14385152 bytes), reduce PostgreSQL's shared memory usage, perhaps by reducing shared_buffers or max_connections.
If the request size is already small, it's possible that it is less than your kernel's SHMMIN parameter,
in which case raising the request size or reconfiguring SHMMIN is called for.
The PostgreSQL documentation contains more information about shared memory configuration.
A definíciók közötti különbségek megértése
Az SHMMAX/SHMALL paraméterek meghatározása kissé eltér Linuxon és MacOS X-en:
- Linux: kernel.shmmax, kernel.shmall
- MacOS X: kern.sysv.shmmax, kern.sysv.shmall
Csapat sysctl az érték ideiglenes megváltoztatására használható. Állandó értékek beállításához adjon hozzá egy bejegyzést /etc/sysctl.conf. A részletek alább olvashatók.
Kernelbeállítások módosítása MacOS X rendszeren
# Get the value of SHMMAX
sudo sysctl kern.sysv.shmmax
kern.sysv.shmmax: 4096
# Get the value of SHMALL
sudo sysctl kern.sysv.shmall
kern.sysv.shmall: 4096
# Set the value of SHMMAX
sudo sysctl -w kern.sysv.shmmax=16777216
kern.sysv.shmmax: 4096 -> 16777216
# Set the value of SHMALL
sudo sysctl -w kern.sysv.shmall=16777216
kern.sysv.shmall: 4096 -> 16777216Kernelparaméterek megváltoztatása Linuxon
# Get the value of SHMMAX
sudo sysctl kernel.shmmax
kernel.shmmax: 4096
# Get the value of SHMALL
sudo sysctl kernel.shmall
kernel.shmall: 4096
# Set the value of SHMMAX
sudo sysctl -w kernel.shmmax=16777216
kernel.shmmax: 4096 -> 16777216
# Set the value of SHMALL
sudo sysctl -w kernel.shmall=16777216
kernel.shmall: 4096 -> 16777216Ne felejtsd el: A változtatások véglegessé tételéhez adja hozzá ezeket az értékeket az /etc/sysctl.conf fájlhoz
Hatalmas oldalak
A Linux alapértelmezés szerint 4 KB-os memórialapokat használ, a BSD pedig XNUMX KB-os memóriaoldalakat. Super Pagesés Windows rendszeren - Nagy oldalak. Az oldal a RAM egy darabja, amely egy folyamathoz van lefoglalva. A memóriaigénytől függően egy folyamat több oldalas is lehet. Minél több memóriát igényel egy folyamat, annál több oldalt foglal le. Az operációs rendszer oldalfoglalási táblázatot tart fenn a folyamatokhoz. Minél kisebb az oldal mérete, minél nagyobb a táblázat, annál tovább tart egy oldal megtalálása az adott oldaltáblázatban. A nagy oldalak ezért nagy mennyiségű memória használatát teszik lehetővé csökkentett többletköltséggel; kevesebb oldalletöltés, kevesebb oldalhiba, gyorsabb olvasási/írási műveletek nagyobb puffereken keresztül. Az eredmény jobb teljesítmény.
A PostgreSQL csak a nagy oldalakat támogatja Linuxon. A Linux alapértelmezés szerint 4 KB-os memóriaoldalakat használ, ezért olyan esetekben, amikor túl sok a memóriaművelet, nagyobb oldalakat kell beállítani. Teljesítménynövekedés figyelhető meg nagy, 2 MB és legfeljebb 1 GB méretű oldalak használatakor. A nagy oldalméret indításkor állítható be. A paranccsal könnyen ellenőrizheti a nagy oldalparamétereket és azok használatát a Linux gépen cat /proc/meminfo | grep -i hatalmas.
Információk beszerzése nagy oldalakról (csak Linux)
Note: This is only for Linux, for other OS this operation is ignored$ cat /proc/meminfo | grep -i huge
AnonHugePages: 0 kB
ShmemHugePages: 0 kB
HugePages_Total: 0
HugePages_Free: 0
HugePages_Rsvd: 0
HugePages_Surp: 0
Hugepagesize: 2048 kBEbben a példában, bár a nagy oldalméret 2048-ra (2 MB) van beállítva, a nagy oldalak teljes száma 0. Ez azt jelenti, hogy a nagy oldalak le vannak tiltva.
Szkript a nagy oldalak számának meghatározásához
Ez az egyszerű szkript visszaadja a szükséges számú nagy oldalt. Futtassa a szkriptet a Linux-kiszolgálón, miközben a PostgreSQL fut. Győződjön meg arról, hogy a környezeti változónál $PGDATA A PostgreSQL adatkönyvtár meg van adva.
A szükséges számú nagy oldal elérése
#!/bin/bash
pid=`head -1 $PGDATA/postmaster.pid`
echo "Pid: $pid"
peak=`grep ^VmPeak /proc/$pid/status | awk '{ print $2 }'`
echo "VmPeak: $peak kB"
hps=`grep ^Hugepagesize /proc/meminfo | awk '{ print $2 }'`
echo "Hugepagesize: $hps kB"
hp=$((peak/hps))
echo Set Huge Pages: $hpA szkript kimenete így néz ki:
Szkript kimenet
Pid: 12737
VmPeak: 180932 kB
Hugepagesize: 2048 kB
Set Huge Pages: 88Nagy oldalak esetén a javasolt érték 88, ezért érdemes 88-ra állítani.
Nagy oldalak telepítése
sysctl -w vm.nr_hugepages=88Ellenőrizze most a nagy oldalakat, látni fogja, hogy a nagy oldalak nincsenek használatban (HugePages_Free = HugePages_Total).
Nagy oldalak újralátogatása (csak Linux)
$ cat /proc/meminfo | grep -i huge
AnonHugePages: 0 kB
ShmemHugePages: 0 kB
HugePages_Total: 88
HugePages_Free: 88
HugePages_Rsvd: 0
HugePages_Surp: 0
Hugepagesize: 2048 kBMost állítsa a huge_pages paramétert "on" értékre a $PGDATA/postgresql.conf fájlban, és indítsa újra a szervert.
Ismét információ a nagy oldalakkal kapcsolatban (csak Linuxon)
$ cat /proc/meminfo | grep -i huge
AnonHugePages: 0 kB
ShmemHugePages: 0 kB
HugePages_Total: 88
HugePages_Free: 81
HugePages_Rsvd: 64
HugePages_Surp: 0
Hugepagesize: 2048 kBMost láthatja, hogy nagyon kevés nagy oldalt használnak. Most próbáljunk meg néhány adatot hozzáadni az adatbázishoz.
Egyes adatbázis-műveletek nagy oldalak újrahasznosítására
postgres=# CREATE TABLE foo(a INTEGER);
CREATE TABLE
postgres=# INSERT INTO foo VALUES(generate_Series(1,10000000));
INSERT 0 10000000Lássuk, használunk-e most több nagy oldalt, mint korábban.
További információ a nagy oldalakon (csak Linuxon)
$ cat /proc/meminfo | grep -i huge
AnonHugePages: 0 kB
ShmemHugePages: 0 kB
HugePages_Total: 88
HugePages_Free: 18
HugePages_Rsvd: 1
HugePages_Surp: 0
Hugepagesize: 2048 kBMost már láthatja, hogy a legtöbb nagy oldal használatban van.
Megjegyzés: Az itt használt HugePages becsült értéke nagyon alacsony, ami nem normális érték egy termékkörnyezetet futtató gépen. Kérjük, becsülje meg a rendszeréhez szükséges oldalak számát, és állítsa be őket a terhelés és az erőforrások alapján.
vm.cserelehetőség
vm.cserelehetőség egy másik kernelparaméter, amely befolyásolhatja az adatbázis teljesítményét. Ez az opció a csere (lapok cseréje a memóriában és a memóriából) viselkedésének szabályozására szolgál Linuxon. Az érték 0-tól 100-ig terjed. Meghatározza, hogy mennyi memória legyen lapozva vagy lapozva. A nulla azt jelenti, hogy nincs csere, a 100 pedig agresszív cserét.
Alacsonyabb értékek beállításával jó teljesítményt érhet el.
Ha ezt 0-ra állítja újabb kerneleken, az OOM Killer (a Linux memóriatisztító folyamata) leállíthatja a folyamatot. Így nyugodtan állíthatja 1-re, ha minimalizálni szeretné a cserét. A Linux alapértelmezett értéke 60. A magasabb érték miatt az MMU (memóriakezelő egység) több swap területet használ, mint a RAM, míg az alacsonyabb érték több adatot/kódot tart a memóriában.
Az alacsonyabb érték jó tétet jelent a PostgreSQL jobb teljesítményére.
vm.overcommit_memory / vm.overcommit_ratio
Az alkalmazások memóriát szereznek, és felszabadítják, amikor már nincs rá szükség. De bizonyos esetekben az alkalmazás túl sok memóriát kap, és nem engedi fel. Ez OOM-gyilkost okozhat. Itt vannak a lehetséges paraméterértékek vm.overcommit_memory mindegyikhez leírással:
- Heurisztikus túlvállalás (alapértelmezett); kernel alapú heurisztika
- Mindenképpen engedélyezze a túlvállalást
- Ne vigyük túlzásba, ne lépjük túl a túlvállalási arányt.
URL:
vm.overcommit_ratio — a túlterheléshez rendelkezésre álló RAM százalékos aránya. A 50 GB RAM-mal rendelkező rendszerek 2%-os értéke legfeljebb 3 GB RAM-ot foglalhat le.
A vm.overcommit_memory 2-es értéke jobb teljesítményt biztosít a PostgreSQL számára. Ez az érték maximalizálja a szerverfolyamat RAM-használatát anélkül, hogy jelentős kockázatot jelentene annak, hogy az OOM-killer folyamat megöli. Az alkalmazás újratölthető lesz, de csak a túllépés határain belül, ami csökkenti annak kockázatát, hogy egy OOM-gyilkos megöli a folyamatot. Ezért a 2-es érték jobb teljesítményt nyújt, mint az alapértelmezett 0. A megbízhatóság azonban javítható, ha gondoskodunk arról, hogy a tartományon kívüli memória ne legyen túlterhelve. Ez kiküszöböli annak kockázatát, hogy a folyamatot egy OOM-gyilkos megölje.
Csere nélküli rendszereken a vm.overcommit_memory 2-vel egyenlő probléma léphet fel.
vm.dirty_background_ratio / vm.dirty_background_bytes
vm.dirty_background_ratio a lemezre írandó piszkos oldalakkal töltött memória százalékos aránya. A lemezre öblítés a háttérben történik. Ennek a paraméternek az értéke 0 és 100 között van; az 5 alatti érték azonban hatástalan lehet, és egyes kernelek nem támogatják. A legtöbb Linux rendszeren a 10 az alapértelmezett. Az intenzív írási műveletek teljesítményét kisebb tényezővel javíthatja, ami azt jelenti, hogy a Linux a háttérben kiüríti a piszkos oldalakat.
Be kell állítani az értéket vm.dirty_background_bytes a hajtás sebességétől függően.
Ennek a két paraméternek nincs "jó" értéke, mivel mindkettő hardverfüggő. Azonban a vm.dirty_background_ratio értékének 5-re és a vm.dirty_background_bytes értéknek a lemezsebesség 25%-ára történő beállítása a legtöbb esetben ~25%-ra javítja a teljesítményt.
vm.dirty_ratio/dirty_bytes
Ez ugyanaz, mint vm.dirty_background_ratio/dirty_background_bytes, kivéve, hogy a visszaállítás egy dolgozói munkamenetben történik, blokkolva az alkalmazást. Ezért a vm.dirty_ratio értéknek nagyobbnak kell lennie, mint vm.dirty_background_ratio. Ez biztosítja, hogy a háttérfolyamatok korábban induljanak el, hogy a lehető legnagyobb mértékben elkerüljék az alkalmazás blokkolását. A két arány közötti különbséget a lemez I/O terhelésétől függően módosíthatja.
Teljes
A teljesítmény javítása érdekében más beállításokat is módosíthat, de a fejlesztések minimálisak lesznek, és nem sok hasznot fog látni. Emlékeznünk kell arra, hogy nem minden lehetőség vonatkozik minden típusú alkalmazásra. Egyes alkalmazások jobban működnek, ha módosítunk bizonyos beállításokat, mások pedig nem. Meg kell találnia a megfelelő egyensúlyt ezen beállítások konfigurálása között a várható munkaterheléshez és az alkalmazás típusához, és figyelembe kell vennie az operációs rendszer viselkedését is a hangolás során. A kernelparaméterek konfigurálása nem olyan egyszerű, mint az adatbázisparaméterek konfigurálása, sokkal nehezebb javaslatokat tenni.
Forrás: will.com