RE:NODE

Dimenzování Node.js API s PostgreSQL před nákupem

Text: Tým RE:NODE
16 min čtení


Typické Node.js API s databází PostgreSQL je malé: většina z nich pohodlně běží na 1-2 GB paměti a jednom vCPU a databáze potřebuje zhruba totéž. Poctivý způsob, jak k číslu dojít, není vzorec, ale tři měření na vašem vlastním kódu: špičková rezidentní paměť (RSS) pod zátěží, vytížení event loopu při očekávaném počtu požadavků a počet současně obsazených spojení s databází. Kupte plán, který tato čísla pojme s rezervou kolem 30-40 %, a po každém vydání, které mění dotazy, měřte znovu. Tento návod ukazuje, jak každé měření provést vestavěnými nástroji, jak z nich určit velikost plánu a co větší plán nespraví.

Text je záměrně o měření před utrácením. Pokud už víte, že aplikace padá na limitu paměti, rychlejší bude limity paměti Node.js. Pokud je příznakem chyba spojení s Postgresem, začněte u poolu spojení node-postgres na malých serverech. Obecné rozhodnutí o upgradu pro jakýkoli runtime najdete v kdy upgradovat hostingový plán. Tento příspěvek řeší to, co přichází před nimi: jak velikost vůbec určit.

Co v Node API skutečně spotřebovává zdroje#

Node spouští váš JavaScript v jednom vlákně. Tento fakt určuje celé dimenzování. Proces API může pro váš kód využít nejvýše zhruba jedno jádro, kolik jader plán má, protože event loop provádí všechno - routování, parsování JSON, serializaci, obchodní logiku - jednu úlohu po druhé. Další jádra pomáhají ve třech užších případech: garbage collection běží na pomocných vláknech, thread pool knihovny libuv obsluhuje část práce se souborovým systémem, DNS a kryptografií a můžete spustit více procesů (přes cluster, pm2 nebo více kontejnerů), abyste pro JavaScript využili víc než jedno jádro.

Užitečná otázka tedy nezní „kolik potřebuju jader", ale „jak je vytížený můj jediný event loop při očekávaném provozu". Plán s 1 vCPU a plán se 2 vCPU dají jednomu procesu Node stejný výkon JavaScriptu. Druhé jádro se vyplatí, až když spustíte druhý proces.

Paměť se odhaduje snáz. Proces Node má pevný základ a pak roste podle toho, co váš kód drží:

  • Základ: holý proces s načteným Expressem nebo Fastify obvykle zabírá pár desítek megabajtů. Vaše číslo bude jiné, proto měřte.
  • Halda: objekty, které kód vytvořil a ještě neuvolnil. Žijí tu cache v paměti, velké výsledky dotazů a těla požadavků.
  • Buffery a nativní paměť: nahrávání souborů, komprese, TLS a socketové buffery ovladače pg leží mimo haldu V8, ale uvnitř RSS.
  • Stav na jedno spojení: každé otevřené spojení s databází něco stojí na straně Node a výrazně víc na straně Postgresu (viz dále).

Limit kontejneru se vztahuje na RSS, ne na haldu, proto je třeba sledovat rezidentní paměť. Pokud je vám tento rozdíl nový, přečtěte si nejdřív část o dvou stropech v článku o limitech paměti.

Krok první: sepište zátěž#

Dimenzovat podle „malé API" znamená hádat. Věnujte deset minut čtyřem číslům, i hrubým:

  1. Špičkový počet požadavků za sekundu. Ne denní průměr. Pokud čekáte 50 000 požadavků denně, je to v průměru méně než jeden požadavek za sekundu, jenže provoz je nerovnoměrný a špička 10-20krát vyšší než průměr je běžná. Počítejte se špičkou.
  2. Poměr levných a drahých endpointů. Health check a report agregující milion řádků nejsou stejný požadavek. Vyjmenujte tři nejdražší endpointy.
  3. Dotazů na jeden požadavek. Spočítejte, kolik dotazů do databáze dělá typický požadavek. ORM s líným načítáním vazeb dokáže z jednoho endpointu udělat dvacet dotazů, aniž si toho někdo všimne.
  4. Velikost odpovědi. Průměrná velikost odpovědi v kilobajtech. Velký JSON je procesorový čas vašeho event loopu, protože serializace je synchronní.

Tato čtyři čísla jsou vstupem všeho dalšího. Uložte je do repozitáře vedle kódu, aby další člověk, který bude měnit velikost aplikace, nezačínal od nuly.

Krok druhý: nejdřív měřte na vlastním stroji#

Než se do hry dostane hostingový plán, zjistěte, kolik aplikace stojí v klidu a pod zátěží. Použijte produkční build, NODE_ENV=production a databázi s realistickým objemem dat - tabulka o 200 řádcích skryje každý chybějící index.

Paměť v klidu a pod zátěží

Vypisujte resident set size zevnitř procesu nebo ho sledujte zvenčí:

mem.js
setInterval(() => {  const m = process.memoryUsage();  const mb = (n) => Math.round(n / 1024 / 1024);  console.log(`rss=${mb(m.rss)}MB heapUsed=${mb(m.heapUsed)}MB external=${mb(m.external)}MB`);}, 10000).unref();

Spusťte aplikaci, poznamenejte si RSS v klidu, pak nasaďte zátěž (další část) a po několika minutách si RSS poznamenejte znovu. Rozhoduje plató: paměť, která během zátěže vyroste a ustálí se, je váš pracovní soubor, zatímco paměť rostoucí donekonečna je únik a žádná velikost plánu ho nevyléčí.

Zátěž pomocí autocannonu

autocannon je malý generátor zátěže v Node, který se spouští přes npx bez trvalé instalace:

bash
$ npx autocannon -c 50 -d 30 http://localhost:3000/api/orders

-c 50 je 50 souběžných spojení a -d 30 třicet sekund. Nástroj vypíše rozložení latencí a počet požadavků za sekundu. Pusťte ho zvlášť na každý ze tří drahých endpointů, pak na realistickou směs, a vždy s databází ve smyčce. Zvyšujte -c po krocích (10, 25, 50, 100) a sledujte, kde propustnost přestane růst a latence začne stoupat. Tento zlom je kapacita na daném stroji.

Upozornění: váš notebook není hostingový plán. Místní čísla berte jako relativní (tento endpoint stojí desetkrát víc než támhleten) a konečná absolutní čísla vezměte z krátkého běhu na skutečném serveru, o němž je řeč dále.

Zpoždění event loopu: číslo, které řekne, jestli vás brzdí CPU#

Propustnost říká, jak rychlá aplikace je. Zpoždění event loopu říká, jak blízko je k hraně. Když je proces Node přetížený, požadavky čekají ve frontě za tím, co se právě provádí, a o kolik se zpozdí spuštění časovače, přímo měří tuto frontu.

Node to má vestavěné v perf_hooks:

loop-lag.js
const { monitorEventLoopDelay, performance } = require('node:perf_hooks');const h = monitorEventLoopDelay({ resolution: 20 });h.enable();let last = performance.eventLoopUtilization();setInterval(() => {  const now = performance.eventLoopUtilization();  const util = performance.eventLoopUtilization(now, last).utilization;  last = now;  console.log(JSON.stringify({    loopMeanMs: +(h.mean / 1e6).toFixed(1),    loopP99Ms: +(h.percentile(99) / 1e6).toFixed(1),    loopMaxMs: +(h.max / 1e6).toFixed(1),    utilisation: +util.toFixed(2),  }));  h.reset();}, 10000).unref();

Hodnoty histogramu jsou v nanosekundách, proto se dělí. Vychází dvě metriky a odpovídají na různé otázky:

MetrikaCo říkáOrientačně
Zpoždění event loopu, p99O kolik se v chvostu zpožďují časovačeDo 50 ms je v pořádku; trvale stovky ms je fronta
Vytížení event loopuPodíl času v JS, od 0 do 1Trvale nad 0.7-0.8 znamená málo rezervy

Tyto prahy jsou praktická vodítka, ne standardy. Hledáte trend pod zátěží: zpoždění zůstává ploché, jak přidáváte souběžnost, a pak se prudce zvedne. Místo zlomu je úroveň provozu, na které jeden proces dochází.

Výsledek čtěte takto:

  • Vytížení nízké, latence vysoká. Smyčka je volná, ale požadavky jsou pomalé, takže čas se tráví jinde: obvykle čekáním na databázi nebo na externí API. Víc CPU nepomůže; podívejte se na dotazy a pool.
  • Vytížení kolem 1, zpoždění event loopu vysoké. Jste vázáni na CPU jednoho vlákna. Možnosti od nejlevnější: najít horkou funkci profilem, odstranit synchronní práci, spustit druhý proces, pak rychlejší jádro.
  • Špičky zpoždění při plochém průměru. Jedna pomalá synchronní úloha čas od času zablokuje všechny. Typičtí viníci: JSON.parse obrovského těla, regulární výraz s katastrofickým backtrackingem, bcrypt v synchronním režimu, velké .sort() při každém požadavku.

Abyste horkou funkci našli, a ne hádali, umí Node zapsat profil CPU:

bash
$ node --cpu-prof --cpu-prof-dir=./profiles server.js

Po běhu se zátěží proces zastavte a výsledný soubor .cpuprofile otevřete v Chrome DevTools (panel Performance nebo JavaScript Profiler). Nejširší pruhy jsou místa, kde smyčka tráví čas. Často se zjistí, že jedna serializace JSON nebo jedno volání logování spotřebuje čtvrtinu CPU.

Velikost poolu: skutečným omezením jsou spojení#

Pool ovladače pg má ve výchozím stavu max: 10 spojení na proces Node. Pro mnoho aplikací je to rozumné a pro jiné špatné, a správnou hodnotu je třeba odvodit, ne odhadnout.

Každé spojení s Postgresem je samostatný serverový proces. Drží vlastní paměť a při řazení nebo hashování až work_mem na operaci. Proto větší pool neznamená rychlejší pool: od určitého bodu si další souběžné dotazy jen konkurují o stejné CPU a disk databázového serveru. Paměťovou aritmetiku na straně databáze popisuje ladění PostgreSQL pro malé servery.

Vzorec, který drží

Littleův zákon dává průměrný počet používaných spojení:

code
busy connections = queries per second x average query time (seconds)

Příklad. Špička je 150 požadavků za sekundu, každý spustí 3 dotazy a průměrný dotaz trvá 4 ms:

code
150 x 3 = 450 queries/s450 x 0.004 = 1.8 busy connections on average

Průměry skrývají nárazy, proto plánujte několikanásobek. Pool o velikosti 10 je pro tuto zátěž štědrý. Totéž API s pomalým endpointem reportu, který drží spojení 800 ms a volá se pětkrát za sekundu, potřebuje jen na tento endpoint 5 x 0.8 = 4 spojení a při poolu o velikosti 5 vyhladoví všechno ostatní. Pooly vyčerpávají pomalé dotazy, ne objem požadavků.

Sledujte pool z aplikace

Objekt Pool zpřístupňuje tři čítače, které stojí za to logovat každých pár sekund:

pool-stats.js
setInterval(() => {  console.log(JSON.stringify({    total: pool.totalCount,    idle: pool.idleCount,    waiting: pool.waitingCount,  }));}, 10000).unref();

Pokud je waiting nad nulou déle než chvíli, požadavky čekají ve frontě na spojení. Pokud je idle vysoké a waiting nulové, pool je větší, než potřebuje. Doplňte to rozumnou sadou voleb:

db.js
const { Pool } = require('pg');const pool = new Pool({  connectionString: process.env.DATABASE_URL,  max: 10,  idleTimeoutMillis: 30000,  connectionTimeoutMillis: 5000,  statement_timeout: 15000,});

Pro dimenzování je nejdůležitější connectionTimeoutMillis: bez něj požadavek čeká na volné spojení donekonečna a graf latence se změní v plochou čáru timeoutů místo chyby, kterou by šlo vidět. statement_timeout brání tomu, aby jeden splašený dotaz držel spojení minuty.

Past násobení

Pool je na proces. Pokud spouštíte dva procesy Node (nebo dva kontejnery, nebo cluster se čtyřmi workery), databáze vidí max krát tolik. Zkontrolujte strop databáze:

sql
SHOW max_connections;SELECT state, count(*)FROM pg_stat_activityGROUP BY stateORDER BY count DESC;

Druhý dotaz ukazuje, kolik spojení je active (něco provádějí), idle (drží je pool, ale nic nedělají) a idle in transaction (chyba: někdo začal transakci a neukončil ji). Pokud převažují nečinná spojení, snižte max. Pokud vidíte idle in transaction, opravte kód, protože taková spojení drží zámky a blokují vacuum.

Celková poptávka je processes x max plus vše ostatní, co se připojuje: migrace, worker, relace administrátora, monitorovací agent. Držte tento součet výrazně pod max_connections. Pokud to nejde, dalším krokem je pooler jako PgBouncer nebo menší pooly - ne vyšší max_connections.

Najděte pomalé dotazy dřív, než dimenzujete databázi#

Databáze, která vypadá příliš malá, je velmi často databáze s jedním chybějícím indexem. Dimenzovat stroj kolem špatného dotazu znamená měsíc co měsíc platit za problém, který by odstranil index o jednom řádku. Před volbou plánu databáze věnujte dotazům hodinu.

EXPLAIN (ANALYZE, BUFFERS) dotaz provede a ukáže, kam šel čas:

sql
EXPLAIN (ANALYZE, BUFFERS)SELECT * FROM orders WHERE customer_id = 42 ORDER BY created_at DESC LIMIT 20;

Seq Scan přes velkou tabulku u dotazu, který vrací pár řádků, je klasickým znakem chybějícího indexu. Čtení plánů ukazuje indexy v PostgreSQL vysvětlené. K tomu, které dotazy zkoumat, rozšíření pg_stat_statements je řadí podle celkového času; nastavení a čtení výsledků jsou v hledání pomalých dotazů v PostgreSQL pomocí pg_stat_statements. U hostované databáze nejdřív ověřte, zda je rozšíření dostupné, a nepředpokládejte to.

Potom dimenzujte databázi podle tří věcí:

  • Pracovní sada versus paměť. Postgres je rychlý, když se často čtená část dat vejde do paměti (jeho vlastní cache plus cache operačního systému). Databáze o 2 GB na serveru s 1 GB RAM bude neustále číst z disku.
  • Disk. Data, indexy a write-ahead log. Nechte rezervu: tabulka s intenzivními aktualizacemi roste, než ji vacuum stihne uklidit.
  • Spojení. Z části výše; každé má cenu v paměti.

U RE:NODE začínají plány PostgreSQL na 1 GB paměti a 20 GB disku a nahoru pokračují; aktuální řada je na stránce hostingu databází.

Z měření k plánu#

Teď čísla složte dohromady. Jde o příklad s vymyšlenými, ale realistickými hodnotami, který ukazuje metodu, ne předpověď vašich výsledků.

API pro mobilní aplikaci. Špička je 80 požadavků za sekundu. Místní autocannon ukazuje, že jeden proces se nasytí kolem 400 požadavků za sekundu na směsi drahých endpointů, s vytížením event loopu asi 0.2 na cílové špičce. RSS pod zátěží vystoupá na plató 310 MB. Statistiky poolu ukazují na špičce 3-4 obsazená spojení.

ZdrojNaměřenoPočítat s
Paměť aplikacePlató RSS 310 MBAsi 450-500 MB s rezervou
CPU aplikace20 % jednoho jádra na špičceJeden vCPU, rezerva na čtyřnásobný růst
Spojení s DB3-4 obsazenámax: 10, jeden proces

Taková zátěž se na obou stranách vejde do nejmenších plánů s rezervou. Hlavním důvodem koupit víc by byla paměť databáze, kdyby pracovní sada přerostla 1 GB, což poznáte podle statistik cache v pg_stat_statements a podle rostoucí latence čtení, ne podle dohadů.

Několik praktických pravidel pro přepočet:

  • Rezerva paměti 30-40 % nad plató. Garbage collection potřebuje místo na práci a plató není špička.
  • Nejvýše jeden proces Node na vCPU. Na plánu se 2 vCPU mohou dva procesy využít obě jádra; na 0.5 vCPU bude jeden proces škrcen pod to, co chce.
  • Limity CPU jsou tvrdé škrcení. U RE:NODE je údaj o CPU v plánu zakoupený podíl a je to tvrdý limit, takže vytížený server je pomalý, nikdy ne pozastavený. Zpoždění event loopu je proto první příznak poddimenzovaného plánu, dlouho před objevením chyb. Podrobnosti o řadě plánů jsou na stránce hostingu aplikací.
  • Dejte databázi vlastní plán. Postgres vedle aplikace na jednom malém stroji s ní soupeří o paměť. Samostatný plán databáze dává každému definovaný limit a každý lze měnit zvlášť.

Ověřte na skutečném serveru a sledujte ho#

Jakmile je aplikace nasazená, zopakujte zátěžový test proti ní z jiného stroje a nechte běžet stejná měření. Co sledovat:

  1. Grafy v panelu pro paměť, CPU a disk vůči limitům plánu, na záložce Console. Jednat je třeba, když je paměť pod zátěží u limitu; CPU přilepené na limitu znamená, že škrcení funguje.
  2. Vlastní logy zpoždění smyčky, vytížení a čítačů poolu. Jsou přesnější než jakýkoli graf a přežijí restart, pokud je někam odesíláte.
  3. Limity kontejneru, pokud máte shell: v systému s cgroup v2 ukáže cat /sys/fs/cgroup/cpu.stat hodnoty nr_throttled a throttled_usec, tedy kolikrát vás limit CPU zbrzdil. Přesné soubory závisí na verzi cgroup na hostiteli, takže to berte jako věc k ověření, ne k předpokladu.

Když paměť narazí na limit, jádro kontejner zastaví a ten se čistě restartuje, místo aby swapoval. Je to záměrná volba a znamená, že poddimenzovaný plán se projeví restarty, ne pozvolnou degradací. Tři restarty za hodinu vyvolají varování na stránce serveru a automatický tiket, takže nenechávejte smyčku pádů bez dozoru.

Přidejte lehkou health routu a kontrolu dostupnosti a metriky vyberte podle monitoringu, který něco říká, abyste byli upozorněni na příznaky (latence, chyby), a ne na každé zakolísání.

Kdy přejít na větší plán a kdy to nepomůže#

Větší plán stojí každý měsíc peníze, proto přizpůsobte léčbu diagnóze:

PříznakPravděpodobná příčinaŘešení
Vytížení smyčky kolem 1, zpoždění rosteJedno vlákno je nasycenéProfil, odstranit sync práci, přidat proces
Smyčka volná, latence vysoká, waiting > 0Pool vyčerpaný pomalými dotazyNejdřív dotazy, potom zvýšit max
RSS roste bez platóÚnik pamětiNajít únik, nekupovat RAM
Plató RSS na limitu plánuPaměti je opravdu máloPřejít na další tarif
Čtení z DB zpomaluje s růstem datPracovní sada přesáhla paměťIndexy, pak víc RAM databáze

Přechod o stupeň výš je správný, když měření říká, že limitem je daný zdroj, a levnější opravy jsou hotové: plató paměti do 20 % limitu nebo CPU skutečně nasycené napříč několika procesy. Změna plánu server nepřestavuje, takže posun nahoru je krok s nízkým rizikem, který lze udělat v den, kdy čísla řeknou své. Kupovat „pro jistotu" s rezervou nemá smysl, když je krok nahoru tak levný.

Větší plán nespraví chybějící index, únik spojení, synchronní volání blokující smyčku ani upovídané ORM, které posílá dvacet dotazů na jeden požadavek. To vše se na dalším stupni vrátí, jen později a dráž.

Kdy je odpovědí dedikovaný server

Přechod na dedikovaný server dává smysl v užších případech, než lidé čekají:

  • Provozujete několik služeb na jednom stroji - API, workera, frontu, cache, databázi - a chcete je ladit společně.
  • Potřebujete software, který potřebuje operační systém, například konkrétní build rozšíření Postgresu, vlastní postgresql.conf nebo démony na pozadí.
  • Už používáte největší plán pro aplikace s více procesy a měření stále ukazují nasycení.

Dedikovaná řada RE:NODE je stroj s Intel i9-9900K; aktuální plány a ceny jsou na stránce dedikovaných serverů. Přináší víc rezervy a svobody, ale také víc péče: aktualizace, zálohy a monitoring jsou na vás. Příznaky a postup migrace popisuje kdy aplikace potřebuje dedikovaný server a jak se přesunout a rozdíly mezi třemi variantami vysvětluje VPS, VDS a dedikovaný server.

U většiny samostatných API je pořadí takové: změřit, opravit dotazy, dimenzovat plány aplikace a databáze zvlášť, přejít o stupeň výš, když to měření vyžaduje, a teprve potom uvažovat o dedikovaném stroji.

FAQ#

Kolik RAM potřebuje malé Node.js API?

Změřte plató RSS pod zátěží a přidejte rezervu 30-40 %. Mnoho malých API se ustálí mezi několika stovkami megabajtů a 1 GB, ale číslo závisí na cache, velikosti odpovědí a závislostech, takže údaj z cizí aplikace je jen výchozí odhad.

Kolik jader CPU potřebuje Node.js API?

Jeden proces využije pro JavaScript zhruba jedno jádro, takže jednomu procesu druhé jádro nic nepřinese. Spouštějte jeden proces na každé jádro, které chcete využít. Potřebu posuzujte podle vytížení event loopu: pokud zůstává na vaší špičce nízké, CPU vás neomezuje.

Jaké zpoždění event loopu je u Node API dobré?

Orientačně do 50 ms na p99 a plochá čára je důležitější než jakékoli konkrétní číslo. Trvalé zpoždění ve stovkách milisekund znamená, že požadavky čekají za synchronní prací nebo přetíženým jádrem.

Jaké max nastavit u pg Pool?

Začněte queries per second x average query seconds, vynásobte několikrát kvůli nárazům a mírně zaokrouhlete nahoru. Výchozí hodnota pg je 10 na proces. Nezapomeňte vynásobit počtem procesů a držet součet pod max_connections databáze.

Mají být aplikace a databáze na stejném plánu?

Odděleně se o nich uvažuje snáz: každé má vlastní limit paměti a CPU a jedno můžete měnit, aniž byste sáhli na druhé. RE:NODE prodává se slevou balíček plánu Node.js a plánu PostgreSQL v jedné objednávce, což se pro takové uspořádání hodí; viz stránka hostingu aplikací.

Dá se dimenzování vyzkoušet bez placení?

Ano, lokálně. Spusťte produkční build nad kopií realistických dat, použijte autocannon a výše uvedené úryvky měření a výsledky berte jako relativní. RE:NODE nemá bezplatný tarif, takže závěrečná kontrola na skutečném serveru je krátký placený test, po kterém můžete změnit plán, pokud se čísla s odhadem rozcházejí.

Pomohlo vám to?