SSD Nodes Learn Hosting plans →
మార్గదర్శకాలు Matt Connorద్వారా Matt Connor · అప్‌డేట్ చేయబడింది 2026-10-24

coding agent VPSకు ఎంత RAM అవసరం?

ఒక ఎల్లప్పుడూ నడిచే coding agentకు 4 GB RAM, 2 vCPU సరిపోతాయి. కానీ builds, language servers, Docker వల్ల RAM నిండిపోయి agent hang కావచ్చు.

కోడింగ్ agent VPS కు ఎంత RAM అవసరం?

ఒక repositoryలో నిరంతరం పనిచేసే coding agent కోసం 4 GB RAM మరియు 2 vCPU తో ప్రారంభించండి. sessionలో language server లేదా Docker build చేరిన వెంటనే 8 GB RAM మరియు 4 vCPU కు పెంచండి. చాలా repositoryలలో ఇది మొదటి రోజే జరుగుతుంది. agent process స్వయంగా చిన్నదే. మీ తరఫున agent నడిపించే toolchain వల్లే VPSలో ఎక్కువ వనరులు వినియోగమవుతాయి.

చార్ట్Three working VPS configurations for a cloud-model coding agent
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
  {
    "plan": "Minimum viable",
    "ram_gb": 4,
    "vcpu": 2,
    "disk_gb": 50
  },
  {
    "plan": "Comfortable",
    "ram_gb": 8,
    "vcpu": 4,
    "disk_gb": 100
  },
  {
    "plan": "Team, 4 sessions",
    "ram_gb": 16,
    "vcpu": 8,
    "disk_gb": 200
  }
]

పైన ఉన్న ప్రతి వరుసలో model వేరే చోట నడుస్తుందని, మీరు network ద్వారా పిలిచే API వెనుక అందుబాటులో ఉంటుందని భావించాం. ఈ అంచనానే మొత్తం sizing ప్రశ్నను నిర్ణయిస్తుంది. కాబట్టి ముందుగా దాన్ని నిర్ధారించండి.

మీరు ఏజెంట్‌ను నడుపుతున్నారా, లేదా మోడల్‌ను నడుపుతున్నారా?

క్లౌడ్ మోడల్‌ను పిలిచే కోడింగ్ ఏజెంట్ అనేది షెల్ అనుసంధానించబడిన ఒక నెట్‌వర్క్ క్లయింట్. ఇది ఫైళ్లను మరియు ఒక ప్రణాళికను APIకి పంపి, సమాధానం కోసం వేచి ఉండి, ఆపై ఫైళ్లను ఎడిట్ చేసి స్థానికంగా కమాండ్లను రన్ చేస్తుంది. అది వేచి ఉన్నప్పుడు దాదాపు ఎటువంటి CPUని ఉపయోగించదు. దాని స్వంత మెమరీ వందల మెగాబైట్ల పరిమాణంలో ఉంటుంది, అందుకే తక్కువ సామర్థ్యం గల CPU బాక్స్ దీనికి సరైన యంత్రం.

మోడల్‌ను మీరే స్వయంగా నడపడం అనేది వేరే హార్డ్‌వేర్‌పై పనిచేసే వేరే ఉత్పత్తి. సర్వర్ ఆన్‌లో ఉన్నంత కాలం వెయిట్స్ (weights) మెమరీలోనే ఉంటాయి. 4 బిట్‌లకు క్వాంటైజ్ చేయబడిన 7 బిలియన్ పారామీటర్ల మోడల్ సుమారు 4 GB వెయిట్స్‌ను కలిగి ఉంటుంది (Llama 2 7B అనేది Q4_0లో 3.83 GB మరియు Q4_K_Mలో 4.08 GBగా విడుదలవుతుంది), మరియు దాని పబ్లిషర్ ప్రకారం GPU లేకుండా దీన్ని రన్ చేయడానికి రన్‌టైమ్ ఓవర్‌హెడ్‌తో కలిపి 6.3 నుండి 6.6 GB RAM అవసరం. కాంటెక్స్ట్ పొడవు పెరిగేకొద్దీ కీ/వాల్యూ కాష్ పెరుగుతుంది కాబట్టి, ఎక్కువ కాంటెక్స్ట్ కోసం మరిన్ని వనరులు అవసరమవుతాయి. కేవలం CPUపై అయితే, ఒక షేర్డ్ vCPU సెకనుకు కొన్ని టోకెన్లను మాత్రమే ఉత్పత్తి చేస్తుంది, మరియు ఒక ఏజెంట్ టాస్క్ వేలకొద్దీ టోకెన్లను విడుదల చేయగలదు, కాబట్టి API ద్వారా నిమిషం లోపు పూర్తయ్యే పని స్థానికంగా గంటకు దగ్గరగా సమయం తీసుకుంటుంది. మీకు అదే కావాలంటే, VRAM (GPUపై ఉండే వీడియో మెమరీ) కోసం పరిమాణాన్ని నిర్ణయించుకోండి మరియు ఈ పేజీకి బదులుగా GPU ఉన్న VPS మీకు వాస్తవానికి ఏమి ఇస్తుంది అనే దాని గురించి చదవండి.

కింద ఉన్నవన్నీ క్లౌడ్-మోడల్ సందర్భాన్ని మాత్రమే పరిగణనలోకి తీసుకుంటాయి.

మెమరీని వాస్తవంగా ఏవి ఉపయోగిస్తాయి

చార్ట్Typical resident memory per process on a mid-size repository (MB)
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
  {
    "label": "Agent CLI process, idle",
    "typical_mb": 250,
    "peak_mb": 600
  },
  {
    "label": "TypeScript language server",
    "typical_mb": 700,
    "peak_mb": 2000
  },
  {
    "label": "rust-analyzer, large workspace",
    "typical_mb": 1200,
    "peak_mb": 4000
  },
  {
    "label": "Headless Chrome, one tab",
    "typical_mb": 350,
    "peak_mb": 900
  },
  {
    "label": "Node test run, 4 workers",
    "typical_mb": 1600,
    "peak_mb": 3000
  },
  {
    "label": "Docker image build",
    "typical_mb": 800,
    "peak_mb": 2500
  }
]

ఇవి మధ్యస్థ పరిమాణంలోని ప్రాజెక్ట్‌లకు సాధారణంగా ప్రచురించే గణాంకాలు. వీటిని మీ code గురించి హామీగా కాకుండా, ఒక సాధారణ నమూనాగా పరిగణించండి.

ఈ chart లో 6 వరుసలు ఉన్నాయి. agent అన్నింటికంటే తక్కువ మెమరీని ఉపయోగిస్తుంది. ఇది idle స్థితిలో సుమారు 250 MB వద్ద ఉంటుంది. కారణం, ఇది ఒక సంభాషణను మరియు చిన్న file cache ను మాత్రమే నిర్వహిస్తుంది. TypeScript language server indexing సమయంలో సుమారు 2000 MB కు చేరుతుంది. మీ tsconfig.json నుంచి అందుబాటులో ఉన్న ప్రతి file కోసం ఇది type graph ను నిర్మిస్తుంది. తరువాతి request కు త్వరగా సమాధానం ఇవ్వడానికి ఆ graph ను memory లో ఉంచుతుంది. పెద్ద workspace లో rust-analyzer సాధారణంగా 4000 MB ను దాటుతుంది. workspace లోని ప్రతి crate పై ఇదే కారణం వర్తిస్తుంది.

Headless Chrome browser మరియు ఒక tab కోసం సుమారు 350 MB ఉపయోగిస్తుంది. ప్రతి అదనపు tab కోసం మరో operating system process ప్రారంభమవుతుంది. నలుగురు workers తో Node test run చేస్తే నాలుగు Node processes నడుస్తాయి. అందువల్ల ఇది గరిష్ఠంగా సుమారు 3000 MB కు చేరుతుంది. Docker image build సుమారు 2500 MB వద్ద గరిష్ఠ స్థాయికి చేరుతుంది. కారణం, build container లో మీ project యొక్క compiler ను నడుపుతుంది. అదే సమయంలో daemon layers ను వ్రాస్తుంది.

కొనుగోలు చేసే ముందు మీ స్వంత repository లో వీటిని కొలవండి
sudo apt update && sudo apt install -y time
/usr/bin/time -v -o /tmp/build.rusage npm run build
grep "Maximum resident set size" /tmp/build.rusage

సమాధానం Maximum resident set size (kbytes): 1842160 రూపంలో వస్తుంది. MB కోసం దీనిని 1024తో భాగించండి. GNU time తాను వేచి చూసిన అతిపెద్ద single process ను నివేదిస్తుంది. అందువల్ల నాలుగు workers ను fork చేసే build లో విలువ తక్కువగా కనిపిస్తుంది. అలాంటి సందర్భాల్లో, రెండో shell నుంచి free -h లేదా systemd-cgtop -m ఉపయోగించి మొత్తం system ను monitor చేయండి.

free -h లోని available column ను చదవండి. free column ను చదవకండి. Linux అందుబాటులో ఉన్న ప్రతి spare page ను disk cache కోసం ఉపయోగిస్తుంది. అందువల్ల పూర్తిగా ఆరోగ్యంగా ఉన్న system లో free చిన్నగా ఉండవచ్చు. అది మీకు ఉపయోగకరమైన సమాచారం ఇవ్వదు. కొత్త process వాస్తవంగా పొందగలిగే memory available.

పనిచేసే మూడు configurationలు

కనీసంగా ఉపయోగించగల configuration: 4 GB RAM, 2 vCPU, 50 GB disk. ఒక agent session, ఒక repository, ఒక language server ఉంటాయి. Builds పూర్తయ్యే వరకు వేచి ఉండగలగాలి. ఈ tier పనిచేస్తుంది. అయితే పెద్ద test run మరియు indexing language server ఒకేసారి నడిస్తే, మొదటిసారే out-of-memory killer ను ఎదుర్కొనే అవకాశం ఉంది. Swap జోడించి build workers సంఖ్యకు పరిమితి విధించండి.

సౌకర్యవంతమైన configuration: 8 GB RAM, 4 vCPU, 100 GB disk. ఒక agent, Docker, tests కోసం headless browser ఉంటాయి. ఒక build spike కు సరిపడా అదనపు వనరులు కూడా ఉంటాయి. చాలా మంది single developers కొనుగోలు చేయాల్సిన tier ఇదే. vCPU సంఖ్యను రెట్టింపు చేస్తే build కోసం వేచి ఉండే సమయం కూడా సుమారుగా సగానికి తగ్గుతుంది. Memory కొరత కంటే ఈ ప్రభావం మీకు చాలా తరచుగా కనిపిస్తుంది.

Team configuration: 16 GB RAM, 8 vCPU, 200 GB disk. ఒకేసారి నాలుగు sessions నడుస్తాయి. ప్రతి session కు ప్రత్యేక checkout మరియు ప్రత్యేక toolchain ఉంటాయి. గరిష్ఠ వినియోగాన్ని ఆధారంగా చేసుకుని పరిమాణాన్ని నిర్ణయించండి. ఎందుకంటే నాలుగు idle agents కు దాదాపు ఖర్చు ఉండదు. అదే సమయంలో నాలుగు test runs నడిస్తే, పై పట్టికలోని గరిష్ఠ విలువకు నాలుగు రెట్లు వనరులు అవసరం అవుతాయి.

August 2026 నాటికి, మొదటి row నుంచి చివరి row కు మారితే annual VPS billing లో నెలవారీ ధర సుమారుగా నాలుగు రెట్లు పెరుగుతుంది: దిగువ స్థాయిలో నెలకు single digit dollars, పై స్థాయిలో tens of dollars. Planning చేసే ముందు ప్రస్తుత listing ను పరిశీలించండి. ఆ సంఖ్యలు మారుతుంటాయి. Server ఖర్చు సాధారణంగా ప్రధాన ఖర్చు కాదు. ప్రతిరోజూ agent ను ఉపయోగించే వారికి model API bill త్వరగా server bill కంటే ఎక్కువవుతుంది. అందువల్ల box పరిమాణాన్ని తగ్గించే ముందు agent ఖర్చు చేయడానికి అనుమతించబడిన మొత్తానికి పరిమితి విధించండి. Build కోసం, VPSపై coding agent ను నడిపించే walkthrough account setup మరియు disconnect చేసిన తర్వాత session కొనసాగించడం గురించి వివరిస్తుంది.

RAM అయిపోకముందే డిస్క్ ఎందుకు అయిపోతుంది

చార్ట్Where the disk goes on a working agent box (GB)
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
  {
    "label": "Ubuntu 24.04 base and toolchain",
    "typical_gb": 6
  },
  {
    "label": "One JS monorepo checkout",
    "typical_gb": 3
  },
  {
    "label": "node_modules across 3 branches",
    "typical_gb": 4
  },
  {
    "label": "Docker images and build cache",
    "typical_gb": 20
  },
  {
    "label": "Agent logs and journal, 90 days",
    "typical_gb": 2
  }
]

ఆ వరుసలను కలిపితే, మీరు ఒక్క లైన్ కోడ్ కూడా రాయకముందే 50 GB డిస్క్ దాదాపు నిండిపోతుంది. అన్నింటికంటే పెద్దది Docker, ఇది సుమారు 20 GB ఉంటుంది, ఎందుకంటే మీరు ఆపమని చెప్పే వరకు BuildKit ప్రతి బిల్డ్ యొక్క ప్రతి intermediate లేయర్‌ను అలాగే ఉంచుతుంది.

docker system df
docker builder prune --filter until=168h

docker system df ప్రతి కేటగిరీకి తిరిగి పొందగలిగే స్థలాన్ని చూపిస్తుంది, కాబట్టి దీన్ని ముందుగా మరియు తర్వాత రన్ చేయండి. until=168h ఫిల్టర్ గత వారంలో బిల్డ్ ఉపయోగించిన కాష్ రికార్డులను ఉంచి మిగిలిన వాటిని తొలగిస్తుంది. ఇది వయస్సును బట్టి కాకుండా చివరి వినియోగాన్ని బట్టి పనిచేస్తుంది, కాబట్టి ఒక నెల క్రితం సృష్టించబడిన లేయర్ నిన్న మళ్ళీ ఉపయోగించబడితే అది అలాగే ఉంటుంది, ఆ కాష్ మీకు సమయాన్ని ఆదా చేస్తుంది. docker image prune -a ఇంకా ముందుకు వెళ్లి, ఏ కంటైనర్ ఉపయోగించని ప్రతి ఇమేజ్‌ను తొలగిస్తుంది, కాబట్టి తదుపరి బిల్డ్ మళ్ళీ డౌన్‌లోడ్ చేసుకోవాల్సి ఉంటుందని గమనించండి.

Node ప్రాజెక్ట్‌లు వింతగా విఫలమవుతాయి. npm install లక్షలాది చిన్న ఫైళ్లను రాస్తుంది, కాబట్టి df -h ఇంకా ఖాళీ గిగాబైట్లను చూపిస్తున్నప్పటికీ, ఫైల్‌సిస్టమ్‌లో inodes అయిపోవచ్చు. అప్పుడు డిస్క్ సగం ఖాళీగా ఉన్నట్లు కనిపించినా, రైట్ ఆపరేషన్ No space left on device తో విఫలమవుతుంది.

df -h /
df -i /

ఒకవేళ IUse% 100 అని చూపిస్తే, మీరు ఇకపై ఉపయోగించని బ్రాంచ్‌ల node_modules డైరెక్టరీలను తొలగించండి, లేదా pnpm కి మారండి, ఇది ప్రతి ప్యాకేజీ వెర్షన్‌ను ఒకసారి మాత్రమే నిల్వ చేసి, ప్రతి ప్రాజెక్ట్‌లోకి హార్డ్-లింక్ చేస్తుంది.

లాగ్‌లు నిశ్శబ్దంగా స్థలాన్ని ఆక్రమిస్తాయి. ఎల్లప్పుడూ ఆన్‌లో ఉండే ఏజెంట్ సెషన్ ట్రాన్స్‌క్రిప్ట్‌లను రాస్తుంది, మరియు systemd జర్నల్ డిఫాల్ట్‌గా డిస్క్‌లో కొంత భాగాన్ని ఆక్రమిస్తుంది.

sudo journalctl --disk-usage
sudo journalctl --vacuum-size=200M
du -xh --max-depth=1 / 2>/dev/null | sort -h | tail

/etc/systemd/journald.conf లో SystemMaxUse=200M ని సెట్ చేయండి మరియు ఆ పరిమితిని శాశ్వతం చేయడానికి sudo systemctl restart systemd-journald ని రన్ చేయండి, ఎందుకంటే ఒకసారి చేసే క్లీనప్ కేవలం నేటి స్థలాన్ని మాత్రమే తిరిగి ఇస్తుంది.

Swap: అది అందించేది, అది దాచేది

Swap జోడించడం ఉపయోగకరం. RAM వినియోగం స్వల్పంగా పరిమితిని దాటినప్పుడు process పూర్తిగా ఆగిపోకుండా, నెమ్మదిగా పనిచేసేలా ఇది సహాయపడుతుంది. Swap పరిమాణాన్ని RAMలో సగంగా, గరిష్ఠంగా సుమారు 4 GB వరకు కేటాయించండి. Build box కోసం అంతకంటే ఎక్కువ కేటాయించడానికి సాధారణంగా కారణం ఉండదు.

sudo fallocate -l 4G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab
swapon --show

swapon --show ఇప్పుడు మీరు అడిగిన పరిమాణంలో /swapfile ను చూపాలి. /etc/fstab పంక్తి లేకపోతే తదుపరి reboot తర్వాత swap తొలగిపోతుంది, మరియు సిస్టమ్ నిశ్శబ్దంగా పాత ప్రవర్తనకు తిరిగి వెళ్తుంది. fallocate సమాధానం Operation not supported అయితే, sudo dd if=/dev/zero of=/swapfile bs=1M count=4096 తో ఫైల్‌ను సృష్టించి, chmod నుంచి కొనసాగించండి.

echo 'vm.swappiness = 10' | sudo tee /etc/sysctl.d/99-swappiness.conf
sudo sysctl --system

తక్కువ swappiness విలువ ఉంటే, program memory ని disk కు తరలించే ముందు kernel disk cache ను reclaim చేస్తుంది. దీనివల్ల language server స్పందన వేగంగా ఉంటుంది.

ఇక్కడే swap తన పరిమితిని చూపుతుంది. ఒక job కు సర్వర్‌లో ఉన్నదానికంటే నిజంగా ఎక్కువ memory అవసరమైనప్పుడు, kernel మీ build ను run చేయడానికి బదులుగా RAM మరియు disk మధ్య pages ను తరలించడంలో సమయం గడుపుతుంది. ఏదీ crash కాదు. అయితే అన్ని ప్రక్రియలు చాలా నెమ్మదిస్తాయి. CPU idle గా ఉన్నప్పటికీ load average పెరుగుతుంది.

vmstat 1 10

si మరియు so కాలమ్‌లలో నిరంతరం సున్నా కాని విలువలు కనిపిస్తే, నిరంతర swapping జరుగుతోందని అర్థం. దీనికి పరిష్కారం concurrency తగ్గించడం లేదా RAM పెంచడం; మరింత swap జోడించడం కాదు. చిన్న సిస్టమ్‌లో sudo apt install -y zram-tools RAMలో ఉంచే compressed swap ను అందిస్తుంది. దీన్ని /etc/default/zramswap లో tune చేయవచ్చు. ఇది swap file కంటే చాలా వేగంగా ఉంటుంది. RAMను ఆదా చేయడానికి RAMనే ఉపయోగిస్తుంది. అందువల్ల ఇది cold pages కు సహాయపడుతుంది. నిజమైన working memory అవసరమైన build కు ఇది సహాయపడదు.

మీ కోడింగ్ ఏజెంట్ ఎందుకు హ్యాంగ్ అయినట్లు కనిపిస్తుంది

చిన్న ఏజెంట్ బాక్సుల్లో ఇది అత్యధికంగా తప్పుగా అర్థం చేసుకోబడే వైఫల్యం. ఒక కమాండ్ ఏమీ తిరిగి ఇవ్వదు, ఏజెంట్ వేచి ఉంటుంది, మరియు సెషన్ ఫ్రీజ్ అయినట్లు కనిపిస్తుంది. ఆ ప్రాసెస్‌ను కెర్నల్ అవుట్-ఆఫ్-మెమరీ (OOM) కిల్లర్ ద్వారా చంపడం జరిగింది. దానికి SIGKILL అందింది, కాబట్టి అది ఎర్రర్‌ను ప్రింట్ చేయలేకపోయింది, లాగ్‌ను ఫ్లష్ చేయలేకపోయింది, లేదా ఏమి జరిగిందో ఏజెంట్‌కు చెప్పలేకపోయింది. ఏజెంట్‌కు ఫలితం ఖాళీగా కనిపిస్తుంది మరియు ఎగ్జిట్ మెసేజ్ ఏదీ ఉండదు.

కెర్నల్ దీన్ని రికార్డ్ చేస్తుంది:

sudo dmesg -T | grep -iE "out of memory|killed process"
sudo journalctl -k -b | grep -i oom

నిజమైన లైన్ ఇలా కనిపిస్తుంది:

[Thu Aug  6 11:02:14 2026] Out of memory: Killed process 4711 (node) total-vm:4210880kB, anon-rss:3820104kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:8236kB oom_score_adj:0

anon-rss అనేది ఆ ప్రాసెస్ చనిపోయినప్పుడు అది ఎంత మెమరీని కలిగి ఉందో తెలియజేస్తుంది. ఏ ప్రాసెస్ ఎంపిక చేయబడిందో గమనించండి: కెర్నల్ ఎక్కువగా మెమరీ వినియోగాన్ని బట్టి స్కోర్ చేస్తుంది, కాబట్టి ఇది బాక్స్‌ను పరిమితి దాటించిన బిల్డ్ కంటే తరచుగా లాంగ్వేజ్ సర్వర్‌ను లేదా ఏజెంట్‌ను చంపుతుంది. అందుకే లక్షణం "ఏజెంట్ పాడైపోయింది" అని కనిపిస్తుంది.

Docker లోపల అదే సంఘటన మరింత స్పష్టమైన ఆధారాలను వదిలివేస్తుంది. కంటైనర్ 137 కోడ్‌తో ఎగ్జిట్ అవుతుంది, ఇది 128 ప్లస్ సిగ్నల్ 9.

docker ps -a
docker inspect "$(docker ps -lq)" | grep -i oomkilled

"OOMKilled": true కంటైనర్ తనంతట తానుగా క్రాష్ అవ్వకుండా, మెమరీ పరిమితిని తాకిందని నిర్ధారిస్తుంది.

దీనికి పరిష్కారం ఏమిటంటే, ఖరీదైన కమాండ్‌కు దాని స్వంత పరిమితిని ఇవ్వడం, తద్వారా ఏజెంట్‌కు బదులుగా బిల్డ్ ఆగిపోతుంది:

systemd-run --user --scope -p MemoryMax=4G -- npm run build

ఇప్పుడు బిల్డ్ 4 GB వద్ద ఆగిపోతుంది మరియు ఏజెంట్ సురక్షితంగా ఉంటుంది, ఇది మిస్టరీ హ్యాంగ్‌ను సాధారణ ఎగ్జిట్ కోడ్‌తో కూడిన సాధారణ విఫలమైన కమాండ్‌గా మారుస్తుంది. దీనికి systemd యూజర్ మేనేజర్ అవసరం, మరియు సాధారణ SSH లాగిన్ మీ కోసం ఒకదాన్ని ప్రారంభిస్తుంది, కాబట్టి కమాండ్ SSH ద్వారా అలాగే పనిచేస్తుంది. loginctl enable-linger $USER అనేది మీరు లాగ్ అవుట్ అయిన తర్వాత కూడా యూజర్ యూనిట్లు రన్ అవ్వడానికి మాత్రమే. MemoryHigh= ప్రాసెస్‌ను చంపే బదులు ఆ పరిమితి వద్ద నెమ్మదింపజేస్తుంది, ఇది నెమ్మదిగానైనా పూర్తి కావాలనుకునే బిల్డ్‌లకు మంచి సెట్టింగ్.

Compose memory limits తో ఒకసారి పరిమితి విధించండి

Agent యొక్క tools containers లో నడిస్తే, ప్రతి run లోనూ వర్తించేలా ceiling ను Compose file లో ఉంచండి.

services:
  agent:
    image: node:22-bookworm
    deploy:
      resources:
        limits:
          memory: 2g
          cpus: "1.5"

Docker Compose v2 సాధారణ docker compose up పై deploy.resources.limits ను వర్తింపజేస్తుంది. అందువల్ల swarm mode ఇందులో ఉండదు. పాత mem_limit: 2g key కూడా ఇప్పటికీ పనిచేస్తుంది. Compose memory limits కు సంబంధించిన పూర్తి guide reservations మరియు container తన ceiling ను చేరుకున్నప్పుడు ఏమి జరుగుతుందో వివరిస్తుంది. Server లో Docker ఇంకా లేకపోతే, ముందుగా VPS లో Docker install చేయండి.

ఒక సాధారణ పొరపాటు వల్ల troubleshooting కు ఒక మధ్యాహ్నం మొత్తం వృథా కావచ్చు. 2 GB కు పరిమితమైన container కూడా host యొక్క /proc/meminfo మరియు host యొక్క CPU count ను చదువుతుంది. ఎందుకంటే ఈ రెండింటికీ namespace ఉండదు. CPU count ఆధారంగా worker count ఎంచుకునే test runner, ఎనిమిది vCPUలు ఉన్న host పై 2 GB container లో ఎనిమిది workers ను ప్రారంభిస్తుంది. తరువాత అది 137 తో ఆగిపోతుంది. ఈ సంఖ్యలను మాన్యువల్‌గా సెట్ చేయండి:

npx jest --maxWorkers=2
export NODE_OPTIONS=--max-old-space-size=1536

--max-old-space-size MB లో ఉంటుంది. ఇది V8 heap కు గరిష్ఠ పరిమితిని విధిస్తుంది. దీన్ని container limit కంటే తక్కువగా సెట్ చేయండి. అప్పుడు Node మీరు చదవగల error ను చూపిస్తుంది. ప్రక్రియ మాయం కాదు:

FATAL ERROR: Ineffective mark-compacts near heap limit Allocation failed - JavaScript heap out of memory

ఆ message ఉపయోగకరంగా ఉంటుంది. ఎందుకంటే చేరుకున్న limit మరియు దాన్ని చేరుకున్న process పేరును అది స్పష్టంగా చూపిస్తుంది. OOM killer ఎప్పుడూ అలా చేయదు.

ఒకే సర్వర్‌లో అనేక agent sessions నడపడం

వ్యక్తుల ఆధారంగా కాకుండా ప్రతి session ఆధారంగా ప్రణాళిక రూపొందించండి. ఒకే repositoryలోని రెండు sessions అంటే రెండు language servers, memoryలో build caches యొక్క రెండు సముదాయాలు, అలాగే రెండు agents ఒకేసారి busyగా ఉంటే రెండు test runs అని అర్థం. అందుకే team row 16 GBకు పెరుగుతుంది.

runaway session మొత్తం సర్వర్‌ను నిలిపివేయకుండా ఉండేందుకు ప్రతి userకు కఠినమైన గరిష్ఠ పరిమితిని ఇవ్వండి:

id -u alice
sudo mkdir -p /etc/systemd/system/user-1001.slice.d
printf '[Slice]\nMemoryMax=6G\n' | sudo tee /etc/systemd/system/user-1001.slice.d/limit.conf
sudo systemctl daemon-reload
systemctl show user-1001.slice -p MemoryMax

1001 స్థానంలో id -u చూపించిన UIDని పెట్టండి. User login అయిన తర్వాత systemctl show ఒకసారి MemoryMax=6442450944 ను echo చేయాలి. ఆ user sessionలోని మొత్తం వినియోగం 6 GB దాటితే, kernel ఆమె sliceలోని ఒక processను terminate చేస్తుంది. మిగిలిన ప్రతి session పని కొనసాగిస్తుంది. Agent terminalలో కాకుండా serviceగా నడిస్తే, దాని unit fileలో MemoryMax= ఉంచండి. agentను ఎల్లప్పుడూ నడిచే serviceగా self-host చేయడం కోసం అనుసరించాల్సిన విధానం ఇదే.

FAQ

coding agent కు 2 GB RAM సరిపోతుందా?

agent process కు సరిపోతుంది. అది చేసే పనికి మాత్రం సాధారణంగా సరిపోదు. agent సుమారు 250 MB వరకు ఉపయోగిస్తుంది. అయితే mid-size repository పై ఒక TypeScript language server 2000 MB వరకు చేరవచ్చు. దీనివల్ల 2 GB సర్వర్ swap ఉపయోగించే స్థితికి చేరుతుంది. Configuration files మరియు చిన్న scripts సవరించడానికి 2 GB సరిపోతుంది. Compile చేసే లేదా test suite అమలు చేసే పనులకు కనీసంగా 4 GB ఉపయోగించండి.

VPSలో coding agent నడపడానికి GPU అవసరమా?

agent API ద్వారా cloud model ను పిలిస్తే GPU అవసరం లేదు. ఆ workload network-bound గా ఉంటుంది. అందువల్ల సాధారణ CPU VPS సరైన ఎంపిక. GPU idle గా ఉండి, ఎక్కువ ఖర్చు అవుతుంది. Model అదే సర్వర్‌పై నడిచినప్పుడు మాత్రమే GPU అవసరం. అప్పుడు ప్రశ్న RAM గురించి కాకుండా VRAM మరియు model size గురించి అవుతుంది.

agent VPSకు ఎంత swap జోడించాలి?

RAMలో సగం, గరిష్ఠంగా సుమారు 4 GB వరకు జోడించండి. తాత్కాలికంగా memory వినియోగం పెరిగినప్పుడు swap రక్షణ ఇస్తుంది. Kernel చల్లగా ఉన్న memory pages ను process ను terminate చేయకుండా disk కు తరలించగలదు. అయితే swap ఉపయోగించగల memory పరిమాణాన్ని పెంచదు. vmstat 1 లో si మరియు so columnsలో నిరంతర traffic కనిపిస్తే, సర్వర్ thrashing స్థితిలో ఉంది. తక్కువ parallel workers ఉపయోగించండి లేదా పెద్ద plan కు మారండి.

Build మధ్యలో నా coding agent ఎందుకు freeze అవుతుంది?

Kernel OOM killer build ను terminate చేసి ఉండే అవకాశం చాలా ఎక్కువ. అది SIGKILL పంపుతుంది. అందువల్ల ఏదీ print కాకుండా, ఎప్పటికీ నిండని pipe కోసం agent వేచి ఉంటుంది. sudo dmesg -T | grep -i "killed process" అమలు చేసి process name మరియు దాని anon-rss value చూడండి. systemd-run --user --scope -p MemoryMax=4G ఉపయోగించి buildకు పరిమితి విధించండి, worker count తగ్గించండి లేదా ఒక RAM tier పైకి మారండి.

ఈ వ్యాసం ఉపయోగకరంగా ఉందా?

#sizing#coding-agents#ram#vps-specs#always-on