SSD Nodes Learn Hosting plans →

VPSలో AI agent కోసం headless Chromium ఎలా నడపాలి

VPSలో headless Chromiumకు వచ్చే /dev/shm పరిమితి, sandbox flags, missing fonts, leaked processes సమస్యలను ముందే పరిష్కరించండి. Agent విఫలమయ్యే ముందు limits సెట్ చేయండి.

మీరు నడుపుతున్నది

VPSపై headless browser అంటే window లేకుండా నడిచే Chromium. దీన్ని వ్యక్తి కాకుండా మీ code నియంత్రిస్తుంది. Serverపై ఇది దీర్ఘకాలం నడిచే process treeగా ఉంటుంది. మీ agent local socket ద్వారా దానితో సంభాషిస్తుంది. దీన్ని install చేయడానికి ఒక command చాలు. ఆ తర్వాతి నిర్వహణే ప్రధాన పని. Browser machine నుంచి ఎంత వనరులను ఉపయోగించవచ్చో మీరు పరిమితం చేయాలి. దాని control endpoint public internetకు అందుబాటులో లేకుండా ఉంచాలి.

ఈ guideలో tool ఎంపిక ఇప్పటికే పూర్తయిందని, ఇప్పుడు దాన్ని operate చేయాల్సి ఉందని భావిస్తున్నాం. మీరు ఇంకా crawlers మరియు extractorsను పోల్చి చూస్తుంటే, ముందుగా self-hosted Firecrawl ప్రత్యామ్నాయాలు ను ప్రారంభించి, తరువాత ఇక్కడికి తిరిగి రండి. దిగువన్నీ Playwright యొక్క Chromiumను ఉపయోగిస్తాయి. Playwright తన browser buildతో పాటు తన dependency installerను కూడా అందిస్తుంది. అందువల్ల bare Ubuntu VPSలోనూ containerలోనూ ఇదే commands పనిచేస్తాయి. ఈ commands Playwright 1.62ను నిర్దిష్టంగా ఉపయోగిస్తాయి.

అనివార్య dependencies పై ఊహాగానాలు లేకుండా Chromium ఇన్‌స్టాల్ చేయండి

npm i -D playwright@1.62.0
npx playwright install --with-deps chromium

--with-deps Chromium కు అవసరమైన shared libraries మరియు fonts కోసం apt ను అమలు చేస్తుంది. ఆ దశకు చేరుకున్నప్పుడు root అనుమతిని అడుగుతుంది. Browser build స్వయంగా ఆ command ను అమలు చేసిన user కోసం ~/.cache/ms-playwright లోకి download అవుతుంది. Server పై ఇది ముఖ్యమైన విషయం, ఎందుకంటే service user సాధారణంగా మీరు login అయ్యే user కాదు. sudo npx playwright install-deps chromium తో admin గా system packages ను ఒక్కసారి install చేయండి. తరువాత ఒకే copy భాగస్వామ్యం అయ్యేలా install command మరియు service unit రెండింటిలోనూ PLAYWRIGHT_BROWSERS_PATH=/opt/pw-browsers ను సెట్ చేయండి. Service తన browser ను చూడలేకపోతే, అది వెతికిన path ను పేర్కొంటూ launch సమయంలో విఫలమవుతుంది.

Playwright version ను pin చేయండి. ప్రతి release ఒక browser build కు అనుసంధానమై ఉంటుంది. అందువల్ల pin చేయని npm update నడుస్తున్న service కింద browser ను మార్చవచ్చు. November 16, 2026 నాటికి తాజా release 1.65.1. కాబట్టి pin మార్చే ముందు release notes చదవండి. ARM64 servers పై 1.63 browser folders పేర్లను మార్చిందని గమనించండి. దిగువ AppArmor profile కోసం ఇది ముఖ్యమైన విషయం.

రెండు Chromium builds ఉన్నాయి. అవి ఒకే program కాదు. Headless mode లో Playwright default గా headless shell ను ఉపయోగిస్తుంది. ఇది headless గా మాత్రమే నడిచే చిన్న binary. సాధారణ install దీన్ని full browser పక్కన download చేస్తుంది. npx playwright install --with-deps --only-shell shell ను మాత్రమే install చేస్తుంది. chromium channel తో మీకు full browser లభిస్తుంది. Playwright browser docs దీన్ని "నిజమైన Chrome browser; అందువల్ల ఇది మరింత ప్రామాణికమైనది, నమ్మదగినది, మరియు మరిన్ని features అందిస్తుంది" అని పేర్కొంటాయి. పెద్ద పరిమాణంలో fetching కోసం shell ను ఉపయోగించండి. Site భిన్నంగా ప్రవర్తించినప్పుడు, కారణాన్ని తెలుసుకోవడానికి full browser ను ఉపయోగించండి.

కంటైనర్‌లో headless browser ఎందుకు క్రాష్ అవుతుంది

Docker ప్రతి container కు 64 MB /dev/shm ఇస్తుంది. Docker documentation స్పష్టంగా ఇలా చెబుతుంది: "పరిమాణాన్ని పూర్తిగా పేర్కొనకపోతే, system 64m ను ఉపయోగిస్తుంది". Chromium render చేసిన content ను తన processes మధ్య ఈ shared memory area ద్వారా పంపుతుంది. అందువల్ల ఒక భారీ page దీనిని పూర్తిగా నింపగలదు. అప్పుడు renderer process ఆగిపోతుంది. మీ laptop లో సరిగ్గా పనిచేసే page పై కూడా client crashed target అని చూపిస్తుంది. ఏదైనా మార్చే ముందు container లోపల పరిమాణాన్ని నిర్ధారించండి.

df -h /dev/shm

దీనికి రెండు వాస్తవ పరిష్కారాలు ఉన్నాయి. అవి ప్రత్యామ్నాయాలు, రెండింటినీ కలిపి ఉపయోగించాల్సినవి కావు. --ipc=host ద్వారా container host IPC namespace లోకి వెళ్తుంది. అందువల్ల అది host యొక్క /dev/shm ను ఉపయోగిస్తుంది. దీని పరిమాణం సాధారణంగా RAM లో సగం ఉంటుంది. Playwright's Docker guide దీనిని సిఫారసు చేస్తుంది, ఎందుకంటే ఇది లేకపోతే "Chromium memory అయిపోవడంతో crash కావచ్చు". అయితే దీని వల్ల container మరియు host మధ్య IPC isolation తొలగుతుంది. --shm-size=1g private namespace ను అలాగే ఉంచి, mount పరిమాణాన్ని మాత్రమే పెంచుతుంది.

docker run --rm -it --init --ipc=host --user pwuser mcr.microsoft.com/playwright:v1.62.0-noble /bin/bash

--disable-dev-shm-usage flag చాలా search results లో కనిపించే పరిష్కారం. అయితే అది వేరే పని చేస్తుంది: ఆ files ను /dev/shm నుండి temporary directory కి తరలిస్తుంది. /tmp disk పై ఉంటే, crash కు బదులుగా నెమ్మదైన rendering మరియు disk writes ను పొందుతారు. /tmp tmpfs అయితే data మళ్లీ RAM లోనే ఉంటుంది. దాని పరిమాణాన్ని tmpfs size limit మాత్రమే పరిమితం చేస్తుంది. the kernel documentation ప్రకారం, ఆ limit default గా physical RAM లో సగం ఉంటుంది. tmpfs pages swap కు తరలించబడవచ్చు. చిన్న VPS లో browser అధిక memory వినియోగించడానికి ఇది ఒక కారణం. Playwright 1.62 default గా --disable-dev-shm-usage ను pass చేస్తుంది. మీరు పరిమాణం నిర్ణయించిన /dev/shm ను ఉపయోగించాలంటే, launch options లో ignoreDefaultArgs: ['--disable-dev-shm-usage'] తో ఆ argument ను తొలగించండి.

--no-sandbox వల్ల కలిగే అసలు నష్టం

Chromium ప్రతి renderer ను Linux user namespaces ఆధారంగా నిర్మించిన sandbox లో వేరు చేస్తుంది. ఆ sandbox, ప్రమాదకరమైన page మరియు మీ server మధ్య రక్షణ సరిహద్దిగా ఉంటుంది. Playwright డిఫాల్ట్‌గా Chromium sandboxing ను disable చేస్తుంది. అందువల్ల launch options లో chromiumSandbox: true తో దాన్ని enable చేయండి. Enable చేసిన sandbox ప్రారంభం కాకపోతే Chromium అమలు కావడానికి నిరాకరిస్తుంది. Log లో ఇలాంటి line కనిపిస్తుంది:

Failed to move to new namespace: PID namespaces supported, Network namespace supported, but failed: errno = Operation not permitted

సాధారణంగా --no-sandbox ఉపయోగించమని సూచిస్తారు. Chromium యొక్క స్వంత security pages దీని మూల్యం గురించి స్పష్టంగా చెబుతున్నాయి: "We do not encourage this as it will significantly reduce your security, and may prevent Chromium from working properly." Links ను అనుసరించే agent నిర్వచనం ప్రకారం open web ను browse చేస్తుంది. అందువల్ల తగ్గిన security సరిగ్గా అక్కడే పరీక్షించబడుతుంది. అసలు కారణాన్ని కనుగొనండి.

Root గా అమలు చేయడం మరియు user namespaces నిరోధించబడటం పరిశీలించాల్సిన రెండు కారణాలు. Root గా అమలు చేస్తున్నప్పుడు Chromium sandbox అందుబాటులో ఉండదు. అందుకే Playwright image లో pwuser అనే సాధారణ user ఉంటుంది. Docker లో sandboxed browsing కోసం clone, setns మరియు unshare ను అనుమతించే seccomp profile ను కూడా Playwright సిఫారసు చేస్తుంది. Ubuntu 24.04 మరియు తరువాతి versions లో AppArmor, unprivileged user namespaces ను పరిమితం చేస్తుంది. Shipped profile ఏదీ కవర్ చేయని path లో Chromium binary ఉంటే దానికి అనుమతి నిరాకరించబడుతుంది. ~/.cache/ms-playwright కింద Playwright download సరిగ్గా అలాంటి path లో ఉంటుంది. రెండింటినీ పరిశీలించండి:

id -u
sysctl kernel.apparmor_restrict_unprivileged_userns
sudo dmesg | grep -i userns_create

sysctl నుంచి వచ్చిన 1 మరియు apparmor="DENIED" operation="userns_create" ఉన్న kernel line రెండో కారణాన్ని నిర్ధారిస్తాయి. మిగతా system అంతటికీ restriction కొనసాగేటట్లు, ఆ ఒక్క binary ను /etc/apparmor.d/pw-chromium లో అనుమతించండి:

abi <abi/4.0>,
include <tunables/global>

profile pw-chromium /{home/*/.cache/ms-playwright,opt/pw-browsers}/*/chrome-*/{chrome,headless_shell,chrome-headless-shell} flags=(unconfined) {
  userns,
}

దాన్ని sudo apparmor_parser -r /etc/apparmor.d/pw-chromium తో load చేయండి. x86-64 లో Playwright పూర్తి browser ను chrome-linux64/chrome వద్ద, shell ను chrome-headless-shell-linux64/chrome-headless-shell వద్ద ఉంచుతుంది. ARM64 లో Playwright 1.62 వాటిని వేర్వేరు directories లో install చేసింది: chromium-<revision>/chrome-linux/chrome మరియు chromium_headless_shell-<revision>/chrome-linux/headless_shell. 1.63 నుంచి ARM64, chrome-linux-arm64/chrome మరియు chrome-headless-shell-linux-arm64/chrome-headless-shell తో x86-64 pattern ను అనుసరిస్తుంది. chrome-* glob ఈ layouts అన్నింటినీ కవర్ చేస్తుంది. /opt/pw-browsers branch, PLAYWRIGHT_BROWSERS_PATH తో చేసిన shared install ను కవర్ చేస్తుంది. ఆ path లో browser revision కూడా ఉంటుంది. అందువల్ల ప్రతి Playwright upgrade సమయంలో అది మారుతుంది. పై globs ఈ మార్పును తట్టుకుంటాయి. ఒక exact path ఆధారంగా రాసిన profile నిశ్శబ్దంగా matching ఆపివేస్తుంది. సంబంధంలేనిదిగా కనిపించిన update తర్వాత browser మళ్లీ విఫలమవుతుంది.

స్క్రీన్‌షాట్‌లు ఖాళీగా లేదా బాక్సులతో నిండుగా ఎందుకు వస్తాయి

ఖాళీ స్క్రీన్‌షాట్ లేదా ఖాళీ దీర్ఘచతురస్రాలతో నిండిన స్క్రీన్‌షాట్ సాధారణంగా rendering bug వల్ల కాకుండా font సమస్య వల్ల వస్తుంది. install-deps పనిచేసే ప్రాథమిక font సమితిని తీసుకుంటుంది: fonts-liberation, fonts-freefont-ttf, fonts-noto-color-emoji, fonts-unifont, Japanese కోసం fonts-ipafont-gothic, Chinese కోసం fonts-wqy-zenhei, Thai కోసం fonts-tlwg-loma-otf. ఆ సమితిలో Noto CJK లేదు. అందువల్ల Korean మరియు మరికొన్ని scripts fontconfig కనుగొనగల font కు fallback అవుతాయి. ఊహించకుండా fontconfig ను అడగండి:

fc-match "sans-serif:lang=ko"
fc-match "sans-serif:lang=ar"
fc-list | wc -l

మీకు అవసరమైన ఏదైనా language unifont కు లేదా నిజమైన glyphలు లేని fallback కు resolve అయితే, fonts-noto-core మరియు fonts-noto-cjk install చేసి, check ను మళ్లీ run చేయండి. Fontconfig తన ఫలితాలను cache చేస్తుంది. అందువల్ల fonts install చేసిన తర్వాత browser ను restart చేయండి. ఎలాంటి fonts లేని stripped image startup సమయంలో Fontconfig error: Cannot load default config file ను log చేస్తుంది మరియు ప్రతి page ను ఖాళీగా render చేస్తుంది.

Locale మరియు time zone fonts కు వేరు. అవి page ఎలా కనిపిస్తుందో మాత్రమే కాకుండా, page ఏమి చెబుతుందో కూడా మార్చుతాయి. Playwright context locale మరియు time zone system settings కు default అవుతాయి. అందువల్ల LANG unset అయిందని లేదా time zone UTC అని ఊహించకుండా image configuration ను check చేయండి. వాటిని machine స్థాయిలో కాకుండా ప్రతి browser context కు per-context గా set చేయండి. అప్పుడు ఒకే browser వేర్వేరు regions కోసం tasks ను అందించగలదు.

const context = await browser.newContext({
  locale: 'en-GB',
  timezoneId: 'Europe/Paris',
});

లీకైన browser processes ఎందుకు సర్వర్‌ను swap ఉపయోగించేలా చేస్తాయి

"zombie" అనే పేరు రెండు వేర్వేరు సమస్యలకు ఉపయోగిస్తారు. నిజమైన zombie అనేది పూర్తయిన process. దాని parent process ఎప్పుడూ wait() ను పిలవలేదు. అది PID entry ను మాత్రమే ఉంచుతుంది; మరేమీ ఉంచదు. అందువల్ల అది memoryని వినియోగించదు. Containerలో browser PID 1గా నడిచినప్పుడు ఇటువంటి processes పేరుకుపోతాయి, ఎందుకంటే PID 1కు default reaper ఉండదు. Dockerలోని --init flag దీనినే సరిచేస్తుంది. అది "signals ను forward చేసి processes ను reap చేసే" చిన్న initను నడుపుతుంది. Composeలో దీనికి సమానమైనది init: true.

మీ సర్వర్ swap ఉపయోగించేలా చేసే leak మాత్రం వేరు: ఎవరూ close చేయని live Chromium processes. newContext() మరియు close() మధ్యలో taskలో exception వచ్చినప్పుడు, లేదా controlling scriptను kill చేయడం వల్ల దాని browser tree orphaned అయినప్పుడు ఇది జరుగుతుంది. ప్రతి request కోసం కొత్త browserను launch చేసే code అత్యంత సమస్యాత్మకమైనది. వాటిని లెక్కించండి:

pgrep -c -f 'headless_shell|chrome'
ps -eo pid,ppid,rss,etime,comm --sort=-rss | head -20

Tasks మధ్య ఈ count idle విలువకు తిరిగి రావాలి. ఒక రోజులో అది పెరుగుతూ ఉంటే, పరిష్కారం launch flagsలో కాదు; మీ codeలో ఉంటుంది. finally blockలో contextను close చేయండి, SIGTERM సమయంలో browserను close చేయండి. ఒక browserను నెలరోజులు నడపకుండా, నిర్దిష్ట సంఖ్యలో tasks పూర్తైన తర్వాత దాన్ని మళ్లీ ప్రారంభించండి. systemd కింద stop లేదా restart ఆ unitకు చెందిన cgroupలోని ప్రతిదాన్ని kill చేస్తుంది. అందువల్ల sudo systemctl restart browser.service నమ్మదగిన reset విధానం. Terminal multiplexerలో చేతితో ప్రారంభించిన browserకు ఇలాంటి హామీ ఉండదు. దాని orphan processes session ముగిసిన తర్వాత కూడా కొనసాగుతాయి.

ఒక browser context కు ఎంత RAM అవసరం

ఈ ప్రశ్నను ఖచ్చితంగా అడగాలి, ఎందుకంటే “ఒక browser” అంటే ఒకే process కాదు. Chromium ఒక browser process, ఒక GPU process, utility processes, అలాగే ప్రతి site కు ఒక renderer process నడుపుతుంది. Site isolation వల్ల cross-site iframes కు కూడా ప్రత్యేక renderer లభిస్తుంది. ఒక BrowserContext అంటే అదే process tree లోని ప్రత్యేక cookie jar మరియు storage area. అందువల్ల రెండో context కు తక్కువ వనరులే అవసరం. రెండో page కు మాత్రం అలా కాదు. అది renderer processes ప్రారంభిస్తుంది. ప్రకటనలు ఎక్కువగా ఉన్న page అనేక renderer processes ప్రారంభించవచ్చు.

కాబట్టి మీ స్వంత workload కింద మొత్తం process tree ఉపయోగించే peak memory ను కొలవాలి. మరొకరి blog లోని సంఖ్య ఇక్కడ ఉపయోగం ఉండదు, ఎందుకంటే మీ agent తెరిచే pages ఆధారంగానే సమాధానం మారుతుంది. మీరు ఉపయోగించబోయే machine పై, సందర్శించబోయే sites తో కొలవండి:

sudo systemd-run --unit=browser-probe -p MemoryMax=2G -p MemorySwapMax=0 -p WorkingDirectory=/srv/agent /usr/bin/node worker.js
systemctl status browser-probe

Ubuntu 24.04 లో ఆ output లోని Memory: line unit యొక్క ప్రస్తుత usage మరియు peak usage రెండింటినీ చూపిస్తుంది. Worker ను ఒకేసారి ఒక page తో నడిపి peak ను నమోదు చేయండి. తరువాత రెండు pages తెరిచి మళ్లీ కొలవండి. అప్పుడు రెండో page కు నిజంగా ఎంత memory అవసరమో తెలుస్తుంది. Concurrency ను ఇలా లెక్కించాలి: మొత్తం RAM నుంచి machine లోని మిగతా అవసరాల కోసం కావాల్సిన RAM ను తీసివేయండి. కొన్ని వందల MB headroom ఉంచండి. మిగిలిన మొత్తాన్ని ప్రతి worker కు కొలిచిన peak memory తో భాగించండి. ఈ agent నడిచే machine ను size చేయడానికి agent VPS కు ఎంత RAM మరియు CPU అవసరం చూడండి.

ఈ సంఖ్యను రెండు చోట్ల అమలు చేయండి. మీ code లో fixed worker pool లేదా semaphore ఉపయోగించండి. అందువల్ల agent requests ఒక్కసారిగా పెరిగినప్పుడు కొత్త browsers ప్రారంభం కాకుండా queue లో వేచి ఉంటాయి. OS లో cgroup limit ఉపయోగించండి. అప్పుడు queue లోని bug కారణంగా machine మొత్తం నిలిచిపోదు:

[Service]
MemoryMax=2G
MemorySwapMax=0
TasksMax=512
Restart=always

MemorySwapMax=0 కనిపించేదానికంటే ముఖ్యమైనది. ఇది లేకపోతే limit కు చేరువైనప్పుడు cgroup pages ను swap కు పంపవచ్చు. అందువల్ల machine సాధారణంగా నడుస్తూనే ఉంటుంది, కానీ ప్రతి request నెమ్మదిస్తుంది. స్పష్టమైన failure కంటే దీనిని గుర్తించడం కష్టం. Swap సమస్యను కేవలం ఆలస్యం చేస్తుంది: systemd documentation ప్రకారం usage “cannot be contained under the limit, out-of-memory killer is invoked inside the unit”. Swap ను zero కు పరిమితం చేస్తే unit swap ను ఉపయోగించలేదు. Usage ను reclaim ద్వారా నియంత్రించలేకపోతే MemoryMax చేరినప్పుడు OOM kill కు ముందు reclaim ప్రయత్నం జరుగుతుంది. Restart=always ప్రధాన process exit అయినప్పుడు service ను restart చేస్తుంది. అయితే renderer ను మాత్రమే OOM kill చేయడం వల్ల service తప్పనిసరిగా restart అవుతుందని హామీ లేదు. Compose లో ఇదే controls mem_limit, shm_size మరియు init. వీటి గురించి Docker Compose లో memory limits అమర్చడం లో వివరించాం.

బ్రౌజర్ endpoint ను public internet కు అందుబాటులో ఉంచవద్దు

Playwright బ్రౌజర్‌ను serverగా నడిపి, మీ agent కు WebSocket URL అందించగలదు:

const { chromium } = require('playwright');
const server = await chromium.launchServer({ port: 3000 });
console.log(server.wsEndpoint());

ఆ endpoint కు login లేదు. Playwright API documentation దీన్ని స్పష్టంగా చెబుతోంది: "wsPath గురించి తెలిసిన ఏ process లేదా web page అయినా (Playwright లో నడుస్తున్న వాటితో సహా) OS user పై నియంత్రణ సాధించగలదు." Default host localhost. ఇది "loopback interface నుంచి మాత్రమే connections స్వీకరిస్తుంది". అయితే 0.0.0.0 వంటి explicit address ను ఇవ్వడం వల్ల "listening port ను చేరగల ఏదైనా దానికి browser RPC బహిర్గతమవుతుంది" అని documentation హెచ్చరిస్తోంది. Chrome యొక్క స్వంత --remote-debugging-port ఇంకా ప్రమాదకరం. DevTools protocol కు ఎలాంటి authentication లేదు. ఇది పూర్తిగా loopback కు bind అయి ఉండటంపై ఆధారపడుతుంది.

మీరు వాస్తవంగా ఏవి publish చేశారో తనిఖీ చేయండి. VPS నుంచే కాకుండా రెండవ machine నుంచి కూడా తనిఖీ చేయండి:

ss -ltnp

0.0.0.0 కు bind అయిన browser port పై ఉన్న ఏదైనా finding గా పరిగణించాలి. చాలా providers తమ control panel లో ప్రత్యేక network firewall ను అమలు చేస్తారని గుర్తుంచుకోండి. మీ ufw rules కు ఆ firewall గురించి ఏమీ తెలియదు. SSH tunnel లేదా private VPN ద్వారా మరో machine నుంచి endpoint ను చేరండి:

ssh -N -L 3000:127.0.0.1:3000 you@your-vps

ఇక్కడి ప్రమాదం browser సమయాన్ని ఎవరైనా దొంగిలించడంకంటే పెద్దది. మీరు నియంత్రించగల browser మీ network లోనే ఉన్న request-forgery machine వంటిది. ఆ socket ను చేరగల వ్యక్తి http://127.0.0.1:8080, మీ database admin page లేదా cloud metadata address 169.254.169.254 ను fetch చేయించి, page నుంచి response ను చదవగలడు. ఆ request VPS నుంచే వచ్చిందని మీ firewall చూస్తుంది. అందువల్ల అది అనుమతించబడుతుంది. ఈ control endpoint ను ఆ box పై shell access కు సమానంగా పరిగణించండి.

MCP servers కూడా ఇదే విధంగా పనిచేస్తాయి. npx @playwright/mcp@latest --headless --port 8931 localhost పై HTTP ద్వారా సేవ అందిస్తుంది. స్థానిక tool ను public tool గా మార్చే flag --host 0.0.0.0. Playwright MCP "భద్రతా సరిహద్దు కాదు" అని project README స్పష్టంగా చెబుతోంది. Port ను loopback పై ఉంచి, అదే tunnel ద్వారా agent దాన్ని చేరేలా చేయండి.

ఏజెంట్ చదివే పేజీలు నమ్మదగని ఇన్‌పుట్

Open web ను browse చేసే ఏజెంట్, అపరిచితులు రాసిన పాఠ్యాన్ని మీ సూచనలను కూడా కలిగి ఉన్న model కు అందిస్తుంది. ఒక పేజీలో ఆ model ను ఉద్దేశించిన పాఠ్యం ఉండవచ్చు. అందులో పని ఆపమని, tool ను call చేయమని లేదా URL కు data post చేయమని చెప్పవచ్చు. Model రెండింటినీ పాఠ్యంగానే స్వీకరిస్తుంది. అందువల్ల పేజీలోని పదాలను మీ సూచనల నుంచి నమ్మదగిన విధంగా వేరు చేయలేకపోవచ్చు. హానికరమైన పేజీకి ఉపయోగించుకునే అవకాశాలు చాలా తక్కువగా ఉండేలా setup ను రూపొందించండి.

  • Browser ను ప్రత్యేక OS user కింద నడపండి. దాని environment లో SSH keys లేదా cloud credentials ఉండకూడదు.
  • ప్రతి task కు కొత్త context ను ఉపయోగించండి. Playwright MCP తో --isolated చేయండి. ప్రతి task తర్వాత MCP browser ను మూసివేయండి. దీనివల్ల ఆ session యొక్క storage తొలగించబడుతుంది.
  • Job కు అనుమతి ఉన్నప్పుడు origin allowlist ను నిర్వహించండి. Playwright MCP లో --allowed-origins మరియు --blocked-origins ను semicolon-separated lists గా అందించవచ్చు. ఈ filters redirects పై ప్రభావం చూపవు. ఇవి security boundary కూడా కావు.
  • Mail పంపడం లేదా డబ్బు ఖర్చు చేయడం వంటి state ను మార్చే ఏ చర్యకు ముందు human step ను తప్పనిసరి చేయండి.

ఇంకా మెరుగైన పద్ధతి మొత్తం browser ను తొలగించి మళ్లీ నిర్మించగల machine పై ఉంచడం. ఇది తాత్కాలిక VM లో coding agents ను నడపడం వెనుక ఉన్న కారణంతో సమానం. Agent యొక్క అసలు పని open-ended browsing కాకుండా search అయితే, full browser కంటే పరిమితమైన tool సురక్షితం. మీ స్వంత SearXNG ఆధారంగా పనిచేసే search skill హానికరమైన పేజీని ఎప్పుడూ load చేయకుండా results ను అందిస్తుంది.

FAQ

Chromium Dockerలో crash అవుతూ, అదే VPSలో నేరుగా సరిగ్గా ఎందుకు పనిచేస్తుంది?

Containerకు defaultగా 64 MB /dev/shm లభిస్తుంది, కానీ hostలో దానికంటే చాలా పెద్ద పరిమాణం ఉంటుంది. Chromium rendered contentను ఆ shared memory area ద్వారా పంపుతుంది. అందువల్ల భారీ page దాన్ని పూర్తిగా నింపితే renderer process ఆగిపోతుంది. నిర్ధారించడానికి containerలో df -h /dev/shm అమలు చేయండి. తరువాత host యొక్క shared memoryను ఉపయోగించే --ipc=host లేదా container స్వంత shared memory పరిమాణాన్ని పెంచే --shm-size=1g తో ప్రారంభించండి. --disable-dev-shm-usage సమస్యను /tmp కు మాత్రమే మార్చుతుంది. Playwright 1.62 defaultగా ఆ flagను పంపుతుంది. మీరు కేటాయించిన shared memoryను Chromium ఉపయోగించేలా ignoreDefaultArgs: ['--disable-dev-shm-usage'] ఉపయోగించండి.

VPSలో మరే ఇతర సేవలు నడవకపోతే --no-sandbox సురక్షితమేనా?

కాదు. హానికరమైన page మిగిలిన machineను చేరకుండా sandbox అడ్డుకుంటుంది. Chromium security pagesలో ఈ flag గురించి ఇలా పేర్కొన్నారు: "We do not encourage this as it will significantly reduce your security, and may prevent Chromium from working properly." Linksను అనుసరించే agent open webను browse చేస్తుంది. బదులుగా మూల కారణాన్ని పరిష్కరించండి. Browserను rootగా నడపవద్దు. Ubuntu 24.04లో browser binary pathకు userns, కలిగిన AppArmor profileను జోడించండి. దీంతో ఆ ఒక్క programకు మాత్రమే unprivileged user namespaces అనుమతించబడతాయి. chromiumSandbox: true తో sandboxingను స్పష్టంగా ప్రారంభించండి. Dockerలో Playwright సిఫారసు చేసిన seccomp profileను కూడా ఉపయోగించండి.

చిన్న VPSలో ఎన్ని browsers నడపగలను?

ఒక సంఖ్యను అనుకరించకుండా కొలవండి. Chromium ప్రతి siteకు ఒక renderer processను ప్రారంభిస్తుంది. అందువల్ల మీరు తెరిచే pagesపై సంఖ్య ఆధారపడి ఉంటుంది. MemoryMax సెట్ చేసి, systemd-run కింద ఒక workerను నడపండి. systemctl status లోని Memory: line నుంచి గరిష్ఠ వినియోగాన్ని చదవండి. తరువాత మీ free RAMను ఆ గరిష్ఠ విలువతో భాగించి, కొంత headroom ఉంచండి. ఈ పరిమితిని రెండుసార్లు అమలు చేయండి: codeలో queueతో, unit fileలో MemoryMax తో. దీంతో requests ఒక్కసారిగా పెరిగినప్పుడు machine swap కాకుండా queueలో వేచి ఉంటాయి.

నా agent మరో machine నుంచి browserకు connect కావచ్చా?

అవును. కానీ portను ఎప్పుడూ 0.0.0.0 కు bind చేయవద్దు. Playwright server endpoint మరియు Chrome DevTools port రెండూ password లేకుండా వాటిని చేరగల ఏ clientకైనా కనెక్షన్‌ను అంగీకరిస్తాయి. Listenerను 127.0.0.1 పై ఉంచి, SSH tunnel లేదా private VPN ద్వారా connectionను పంపండి. Serverలో ss -ltnp తో నిర్ధారించండి. బయట నుంచి port check కూడా చేయండి. మీ providerకు ఉన్న ప్రత్యేక network firewallను కూడా పరిశీలించండి.

Page స్పష్టంగా load అయినప్పటికీ నా screenshots ఖాళీగా ఎందుకు ఉన్నాయి?

Fonts అందుబాటులో లేవు. Page scriptకు సరిపడే font లేకపోతే text ఖాళీ boxesగా లేదా పూర్తిగా కనిపించకుండా render అవుతుంది. అందువల్ల image-light page ఖాళీగా కనిపిస్తుంది. మీరు scrape చేసే ప్రతి language కోసం fc-match "sans-serif:lang=ko" అమలు చేయండి. సమాధానం generic fallback అయితే fonts-noto-core మరియు fonts-noto-cjk install చేయండి. తరువాత browserను restart చేయండి, తద్వారా fontconfig తన cacheను మళ్లీ load చేస్తుంది. Fonts అసలు లేని container startup సమయంలో Fontconfig error: Cannot load default config file ను log చేస్తుంది.

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

#headless-browser#playwright#chromium#ai-agents#automation