VPS-ல் Headless Browser இயக்குவது எப்படி?
VPS-ல் Headless Chromium இயக்கும்போது ஏற்படும் /dev/shm பிழைகள், sandbox flags மற்றும் missing fonts சிக்கல்களைத் தவிர்க்கத் தேவையான கட்டமைப்பு முறைகளை இந்த வழிகாட்டி விளக்குகிறது.
நீங்கள் இயக்குவது என்ன
VPS-ல் உள்ள headless browser என்பது விண்டோ இல்லாத Chromium ஆகும்; இது மனிதர்களுக்குப் பதிலாக உங்கள் குறியீட்டின் மூலம் இயக்கப்படுகிறது. சர்வரில் இது நீண்ட காலம் இயங்கும் process tree ஆகும்; உங்கள் ஏஜென்ட் இதனுடன் local socket வழியாகத் தொடர்பு கொள்கிறது. இதை நிறுவுவதற்கு ஒரே ஒரு கட்டளை போதும். அதற்குப் பிறகு செய்யும் வேலைகளே முக்கியமானவை. பிரவுசர் கணினியிலிருந்து எவ்வளவு வளங்களைப் பயன்படுத்தலாம் என்பதை நீங்கள் கட்டுப்படுத்த வேண்டும், மேலும் அதன் control endpoint-ஐ பொது இணையத்திலிருந்து மறைத்து வைக்க வேண்டும்.
இந்த வழிகாட்டி, நீங்கள் ஏற்கனவே ஒரு கருவியைத் தேர்ந்தெடுத்துவிட்டீர்கள் என்றும், இப்போது அதை இயக்க வேண்டும் என்றும் கருதுகிறது. நீங்கள் இன்னும் crawlers மற்றும் extractors-களை ஒப்பிட்டுக்கொண்டிருந்தால், முதலில் self-hosted Firecrawl மாற்றுகளை பார்த்துவிட்டு மீண்டும் வரவும். கீழே உள்ள அனைத்தும் Playwright-ன் Chromium-ஐப் பயன்படுத்துகின்றன, ஏனெனில் Playwright தனது சொந்த பிரவுசர் build மற்றும் dependency installer-ஐக் கொண்டுள்ளது. எனவே, bare Ubuntu VPS மற்றும் container ஆகிய இரண்டிலும் ஒரே கட்டளைகள் வேலை செய்யும். இந்தக் கட்டளைகள் Playwright 1.62-ஐப் பயன்படுத்துகின்றன.
Chromium-ஐ dependencies பற்றி கவலைப்படாமல் நிறுவுதல்
npm i -D playwright@1.62.0
npx playwright install --with-deps chromium--with-deps, Chromium-க்குத் தேவையான shared libraries மற்றும் fonts-க்காக apt-ஐ இயக்குகிறது; தேவைப்படும்போது root அனுமதியைக் கேட்கிறது. Browser build, கட்டளையை இயக்கும் பயனருக்காக ~/.cache/ms-playwright-ல் பதிவிறக்கம் செய்யப்படுகிறது. இது server-ல் முக்கியமானது, ஏனெனில் நீங்கள் login செய்யும் பயனரும், service-ஐ இயக்கும் பயனரும் பொதுவாக வெவ்வேறானவர்கள். sudo npx playwright install-deps chromium-ஐப் பயன்படுத்தி ஒருமுறை admin-ஆக system packages-ஐ நிறுவவும். பின்னர், ஒரே நகலைப் பகிர்ந்துகொள்ள, install கட்டளை மற்றும் service unit ஆகிய இரண்டிலும் PLAYWRIGHT_BROWSERS_PATH=/opt/pw-browsers-ஐ அமைக்கவும். Browser-ஐக் கண்டறிய முடியாத service, அது தேடிய பாதையைக் குறிப்பிட்டு பிழைச் செய்தியுடன் தொடக்கத்திலேயே நின்றுவிடும்.
Playwright பதிப்பை (version) pin செய்யவும். ஒவ்வொரு release-ம் ஒரு குறிப்பிட்ட browser build-உடன் இணைக்கப்பட்டிருக்கும், எனவே pin செய்யப்படாத npm update, இயங்கிக்கொண்டிருக்கும் service-ன் கீழ் உள்ள browser-ஐ மாற்றிவிடக்கூடும். நவம்பர் 16, 2026 நிலவரப்படி, சமீபத்திய release 1.65.1 ஆகும்; எனவே pin-ஐ மாற்றுவதற்கு முன் release notes-ஐப் படிக்கவும். ARM64 server-களில், 1.63 பதிப்பில் browser folders-ன் பெயர்கள் மாற்றப்பட்டுள்ளன என்பதைக் கவனத்தில் கொள்ளவும்; இது கீழே உள்ள AppArmor profile-க்கு முக்கியமானது.
இரண்டு வகையான Chromium builds உள்ளன, அவை ஒரே program அல்ல. Headless mode-ல், Playwright இயல்பாகவே headless shell-ஐப் பயன்படுத்துகிறது; இது headless-ஆக மட்டுமே இயங்கக்கூடிய சிறிய binary ஆகும். சாதாரண install, இதை முழுமையான browser-க்கு அருகிலேயே பதிவிறக்கும், மேலும் npx playwright install --with-deps --only-shell shell-ஐ மட்டும் நிறுவும். chromium channel மூலம் நீங்கள் பெறுவது முழுமையான browser ஆகும். இதை Playwright-ன் browser ஆவணங்கள் "உண்மையான Chrome browser, எனவே இது அதிக நம்பகத்தன்மை கொண்டது, துல்லியமானது மற்றும் கூடுதல் வசதிகளை வழங்குகிறது" என்று குறிப்பிடுகின்றன. மொத்தமாகத் தரவுகளைப் பெற (bulk fetching) shell-ஐப் பயன்படுத்தவும். ஒரு தளம் வித்தியாசமாகச் செயல்பட்டு, அதற்கான காரணத்தைக் கண்டறிய வேண்டியிருக்கும்போது முழுமையான browser-ஐப் பயன்படுத்தவும்.
headless browser container-ல் ஏன் செயலிழக்கிறது (crashes)
Docker ஒவ்வொரு container-க்கும் 64 MB /dev/shm-ஐ வழங்குகிறது. Docker ஆவணங்கள் இதைத் தெளிவாகக் குறிப்பிடுகின்றன: "நீங்கள் அளவைக் குறிப்பிடவில்லை என்றால், கணினி 64m-ஐப் பயன்படுத்தும்". Chromium தனது process-களுக்கு இடையே render செய்யப்பட்ட உள்ளடக்கத்தை அந்தப் பகிரப்பட்ட நினைவகப் பகுதி (shared memory area) வழியாகவே பரிமாறுகிறது, எனவே ஒரு கனமான பக்கம் அதை எளிதில் நிரப்பிவிடும். இதனால் renderer செயலிழக்கும், உங்கள் laptop-ல் சரியாக இயங்கும் ஒரு பக்கம், client-ல் crashed target என்று காட்டும். எதையும் மாற்றுவதற்கு முன், container-க்குள் இருந்து அந்த அளவை உறுதிப்படுத்தவும்.
df -h /dev/shmஇதற்கு இரண்டு உண்மையான தீர்வுகள் உள்ளன, இவை ஒன்றையொன்று மாற்றாகக் கொண்டவை, ஒன்றாகப் பயன்படுத்த வேண்டியவை அல்ல. --ipc=host, container-ஐ host IPC namespace-க்குள் வைக்கிறது, இதனால் அது host-ன் /dev/shm-ஐப் பயன்படுத்தும், இது பொதுவாக RAM-ன் பாதியளவு இருக்கும். Playwright-ன் Docker வழிகாட்டி இதைப் பரிந்துரைக்கிறது, ஏனெனில் இது இல்லையெனில் "Chromium நினைவகம் தீர்ந்து செயலிழக்கக்கூடும்". இதன் விலை என்னவென்றால், 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 பெரும்பாலான தேடல் முடிவுகளில் கிடைக்கும் தீர்வாகும், இது சற்று வித்தியாசமாகச் செயல்படுகிறது: இது அந்த files-ஐ /dev/shm-லிருந்து ஒரு தற்காலிக directory-க்கு மாற்றுகிறது. /tmp வட்டில் (disk) இருந்தால், நீங்கள் crash-ஐத் தவிர்த்துவிட்டு, மெதுவான rendering மற்றும் disk writes-ஐப் பெறுவீர்கள். /tmp ஒரு tmpfs ஆக இருந்தால், தரவு மீண்டும் RAM-க்குச் சென்றுவிடும், அதன் அளவு tmpfs அளவு வரம்பால் மட்டுமே கட்டுப்படுத்தப்படும். kernel ஆவணங்கள் இதை இயல்பாகவே physical RAM-ன் பாதியாக நிர்ணயிக்கின்றன, மேலும் tmpfs பக்கங்களை swap-க்குத் தள்ள முடியும். ஒரு browser சிறிய VPS-ஐ எவ்வாறு பாதிக்கிறது என்பதற்கு இது ஒரு வழியாகும். Playwright 1.62 இயல்பாகவே --disable-dev-shm-usage-ஐ அனுப்புகிறது; நீங்கள் அளவு நிர்ணயித்த /dev/shm-ஐப் பயன்படுத்த, உங்கள் launch options-ல் ignoreDefaultArgs: ['--disable-dev-shm-usage'] மூலம் அந்த argument-ஐ நீக்கவும்.
--no-sandbox என்பதன் உண்மையான விளைவுகள்
Chromium ஒவ்வொரு renderer-ஐயும் Linux user namespaces-ஐ அடிப்படையாகக் கொண்ட ஒரு sandbox-க்குள் தனிமைப்படுத்துகிறது. அந்த sandbox தான் ஒரு ஆபத்தான இணையப்பக்கத்திற்கும் உங்கள் server-க்கும் இடையிலான பாதுகாப்பு எல்லை. Playwright இயல்பாகவே Chromium sandboxing-ஐ முடக்குகிறது, எனவே உங்கள் launch options-ல் chromiumSandbox: true-ஐப் பயன்படுத்தி அதைச் செயல்படுத்தவும். sandbox தொடங்க முடியாதபோது, Chromium இயங்க மறுத்துவிடும், மேலும் log-ல் இது போன்ற ஒரு வரி இடம்பெறும்:
Failed to move to new namespace: PID namespaces supported, Network namespace supported, but failed: errno = Operation not permittedபொதுவாக வழங்கப்படும் அறிவுரை --no-sandbox ஆகும். Chromium-ன் சொந்த பாதுகாப்புப் பக்கங்கள் இதன் விளைவைப் பற்றி வெளிப்படையாகக் கூறுகின்றன: "இதை நாங்கள் ஊக்குவிப்பதில்லை, ஏனெனில் இது உங்கள் பாதுகாப்பை கணிசமாகக் குறைக்கும், மேலும் Chromium சரியாகச் செயல்படுவதைத் தடுக்கலாம்." ஒரு agent இணைப்புகளைப் பின்தொடர்கிறது என்றால், அது திறந்த இணையத்தில் உலாவுகிறது என்று பொருள்; அங்கேதான் இந்த குறைக்கப்பட்ட பாதுகாப்பு சோதிக்கப்படுகிறது. உண்மையான காரணத்தைக் கண்டறியவும்.
root-ஆக இயங்குவது மற்றும் தடுக்கப்பட்ட user namespaces ஆகிய இரண்டும் சரிபார்க்க வேண்டிய காரணங்கள். root-ஆக இயங்கும்போது Chromium-ன் sandbox கிடைக்காது, அதனால்தான் Playwright-ன் image pwuser என்ற சாதாரண user-ஐக் கொண்டுள்ளது. Docker-ல், sandboxed browsing-க்காக clone, setns மற்றும் unshare ஆகியவற்றை அனுமதிக்கும் seccomp profile-ஐ Playwright பரிந்துரைக்கிறது. Ubuntu 24.04 மற்றும் அதற்குப் பிந்தைய பதிப்புகளில், AppArmor சலுகையற்ற user namespaces-ஐக் கட்டுப்படுத்துகிறது, மேலும் எந்த profile-லும் இல்லாத ஒரு பாதையில் உள்ள Chromium binary தடுக்கப்படுகிறது. ~/.cache/ms-playwright-ன் கீழ் Playwright பதிவிறக்கம் செய்யும் கோப்பு அத்தகைய ஒரு பாதையில்தான் உள்ளது. இரண்டையும் சரிபார்க்கவும்:
id -u
sysctl kernel.apparmor_restrict_unprivileged_userns
sudo dmesg | grep -i userns_createsysctl-லிருந்து வரும் ஒரு 1 மற்றும் apparmor="DENIED" operation="userns_create"-ஐக் கொண்ட kernel வரி ஆகியவை இரண்டாவது காரணத்தை உறுதிப்படுத்துகின்றன. அந்த ஒரு 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 மூலம் ஏற்றவும். x86-64-ல், Playwright முழு browser-ஐயும் chrome-linux64/chrome-லும், shell-ஐ chrome-headless-shell-linux64/chrome-headless-shell-லும் வைக்கிறது. ARM64-ல், Playwright 1.62 அவற்றை தனித்தனி கோப்பகங்களில் நிறுவியது: 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 முறையைப் பின்பற்றுகிறது. chrome-* glob இந்த அனைத்து அமைப்புகளையும் உள்ளடக்கும், மேலும் /opt/pw-browsers கிளை PLAYWRIGHT_BROWSERS_PATH மூலம் செய்யப்பட்ட பகிரப்பட்ட நிறுவலை உள்ளடக்கும். இந்தப் பாதையில் browser-ன் பதிப்பும் (revision) இருப்பதால், ஒவ்வொரு Playwright மேம்படுத்தலின் போதும் அது மாறும். மேலே உள்ள globs அந்த மாற்றத்தைத் தாங்கி நிற்கும். ஒரு குறிப்பிட்ட பாதையை மட்டும் வைத்து எழுதப்பட்ட profile, எந்தத் தொடர்பும் இல்லாத ஒரு மேம்படுத்தலுக்குப் பிறகு, அமைதியாகச் செயல்படுவதை நிறுத்திவிடும், மேலும் browser மீண்டும் தோல்வியடையத் தொடங்கும்.
ஸ்கிரீன்ஷாட்கள் ஏன் காலியாகவோ அல்லது கட்டங்களாகவோ வருகின்றன
ஒரு ஸ்கிரீன்ஷாட் காலியாக இருப்பதோ அல்லது அதில் வெறும் கட்டங்கள் தெரிவதோ, பெரும்பாலும் font தொடர்பான சிக்கலே தவிர rendering பிழை அல்ல. install-deps ஒரு இயல்பான அடிப்படை அமைப்பைப் பெறுகிறது: fonts-liberation, fonts-freefont-ttf, fonts-noto-color-emoji, fonts-unifont, ஜப்பானிய மொழிக்கு fonts-ipafont-gothic, சீன மொழிக்கு fonts-wqy-zenhei, தாய் மொழிக்கு fonts-tlwg-loma-otf. இந்தத் தொகுப்பில் Noto CJK இல்லாததால், கொரிய மொழி மற்றும் பிற எழுத்துருக்கள் fontconfig கண்டறியும் ஏதோ ஒரு font-க்கு மாறிவிடுகின்றன. எதையும் ஊகிக்காமல் fontconfig-இடம் சரிபார்க்கவும்:
fc-match "sans-serif:lang=ko"
fc-match "sans-serif:lang=ar"
fc-list | wc -lநீங்கள் பயன்படுத்தும் மொழி unifont என்ற முடிவைத் தந்தாலோ அல்லது சரியான glyphs இல்லாத ஒரு font-க்கு மாறினாலோ, fonts-noto-core மற்றும் fonts-noto-cjk ஆகியவற்றை நிறுவிவிட்டு, மீண்டும் சோதனையை இயக்கவும். Fontconfig அதன் முடிவுகளை cache செய்து வைத்திருக்கும், எனவே புதிய fonts-ஐ நிறுவிய பின் browser-ஐ restart செய்யவும். எந்த font-ம் இல்லாத ஒரு stripped image, தொடங்கும் போது Fontconfig error: Cannot load default config file என்று log செய்யும் மற்றும் ஒவ்வொரு பக்கத்தையும் காலியாகவே காட்டும்.
Locale மற்றும் time zone ஆகியவை fonts-லிருந்து வேறுபட்டவை; இவை பக்கத்தின் தோற்றத்தை மட்டுமல்ல, அதில் உள்ள தகவலையும் மாற்றும். Playwright-ன் context locale மற்றும் time zone ஆகியவை இயல்பாகவே system அமைப்புகளைப் பின்பற்றும். எனவே LANG அமைக்கப்படவில்லை என்றோ அல்லது time zone UTC-ல் தான் உள்ளது என்றோ கருதாமல், image-ன் configuration-ஐச் சரிபார்க்கவும். இவற்றை machine-க்கு ஒன்றாக அமைக்காமல், ஒவ்வொரு browser context-க்கும் தனித்தனியாக அமைக்கவும்; இதன் மூலம் ஒரே browser வெவ்வேறு பிராந்தியங்களுக்கான பணிகளைச் செய்ய முடியும்.
const context = await browser.newContext({
locale: 'en-GB',
timezoneId: 'Europe/Paris',
});Browser processes கசிவு ஏன் server-ல் swap-ஐ ஏற்படுத்துகிறது
"Zombie" என்ற பெயர் இரண்டு வெவ்வேறு சிக்கல்களைக் குறிக்கிறது. ஒரு உண்மையான zombie என்பது, அதன் parent process wait()-ஐ அழைக்காததால் முடிவடைந்த ஒரு process ஆகும். இது ஒரு PID entry-ஐ மட்டுமே வைத்திருக்கும், எனவே இது memory-ஐப் பயன்படுத்தாது. Browser-ஐ ஒரு container-ல் PID 1 ஆக இயக்கும்போது இவை உருவாகின்றன, ஏனெனில் PID 1-க்கு இயல்பான reaper கிடையாது. Docker-ன் --init flag, "signals-ஐ forward செய்து process-களை reap செய்யும்" ஒரு சிறிய init-ஐ இயக்குவதன் மூலம் இந்தச் சிக்கலைச் சரிசெய்கிறது. Compose-ல் இதையே init: true மூலம் செய்யலாம்.
உங்கள் server-ல் swap-ஐ ஏற்படுத்தும் கசிவு வேறுபட்டது: இவை யாரும் மூடாத, இயங்கிக்கொண்டிருக்கும் Chromium process-கள். newContext() மற்றும் close()-க்கு இடையே ஒரு task தோல்வியடையும்போதோ, அல்லது controlling script கொல்லப்பட்டு அதன் browser tree அனாதையாக விடப்படும்போதோ இது நிகழ்கிறது. ஒவ்வொரு request-க்கும் ஒரு புதிய browser-ஐத் தொடங்கும் குறியீடு (code) மிகவும் மோசமானது. அவற்றை எண்ணிப் பாருங்கள்:
pgrep -c -f 'headless_shell|chrome'
ps -eo pid,ppid,rss,etime,comm --sort=-rss | head -20ஒவ்வொரு task-க்கும் இடையில் அந்த எண்ணிக்கை அதன் idle மதிப்பிற்குத் திரும்ப வேண்டும். ஒரு நாள் முழுவதும் அது அதிகரித்துக் கொண்டே இருந்தால், அதற்கான தீர்வு launch flags-ல் இல்லை, உங்கள் குறியீட்டில்தான் உள்ளது: ஒரு finally block-ல் context-ஐ மூடுங்கள், SIGTERM-ல் browser-ஐ மூடுங்கள், மேலும் ஒரு மாதத்திற்கு இயக்குவதற்குப் பதிலாக, குறிப்பிட்ட எண்ணிக்கையிலான task-களுக்குப் பிறகு browser-ஐ recycle செய்யுங்கள். systemd-ன் கீழ், ஒரு stop அல்லது restart அந்த unit-ன் cgroup-ல் உள்ள அனைத்தையும் கொன்றுவிடும், எனவே sudo systemctl restart browser.service ஒரு நம்பகமான reset ஆகும். terminal multiplexer-க்குள் கைமுறையாகத் தொடங்கப்பட்ட browser-க்கு இத்தகைய உத்தரவாதம் இல்லை, அதன் அனாதை process-கள் session முடிந்த பிறகும் இயங்கிக்கொண்டிருக்கும்.
ஒரு browser context-க்கு எவ்வளவு RAM தேவைப்படுகிறது
"ஒரு browser" என்பது ஒரே ஒரு process அல்ல என்பதால், இந்தக் கேள்வியை துல்லியமாகக் கேட்க வேண்டும். Chromium ஒரு browser process, ஒரு GPU process, utility processes மற்றும் ஒவ்வொரு தளத்திற்கும் ஒரு renderer process ஆகியவற்றை இயக்குகிறது. Site isolation வசதி, வெவ்வேறு தளங்களைச் சேர்ந்த iframes-களுக்குத் தனித்தனி renderer-களை வழங்குகிறது. ஒரு BrowserContext என்பது அதே மர அமைப்பிற்குள் இருக்கும் தனித்தனி cookie jar மற்றும் storage பகுதி என்பதால், இரண்டாவது context-க்கு மிகக் குறைந்த அளவே RAM தேவைப்படும். ஆனால், இரண்டாவது பக்கம் (page) அதிக RAM-ஐ எடுத்துக்கொள்ளும், ஏனெனில் அது புதிய renderer process-களைத் தொடங்கும்; விளம்பரங்கள் நிறைந்த பக்கம் பல process-களைத் தொடங்கும்.
எனவே, உங்கள் பணிச்சுமையின் கீழ் முழு மர அமைப்பிற்கும் (tree) தேவைப்படும் உச்சகட்ட நினைவகத்தை (peak memory) அளவிட வேண்டும். மற்றவர்களின் வலைப்பதிவில் உள்ள புள்ளிவிவரங்கள் இதற்குப் பயன்படாது, ஏனெனில் உங்கள் agent எந்தெந்தப் பக்கங்களைத் திறக்கிறதோ அதைப் பொறுத்தே RAM தேவை அமையும். நீங்கள் பயன்படுத்தும் machine-ல், நீங்கள் பார்வையிடப்போகும் தளங்களை வைத்து அளவிடுங்கள்:
sudo systemd-run --unit=browser-probe -p MemoryMax=2G -p MemorySwapMax=0 -p WorkingDirectory=/srv/agent /usr/bin/node worker.js
systemctl status browser-probeUbuntu 24.04-ல், அந்த output-ல் உள்ள Memory: வரி, அந்த unit-ன் தற்போதைய மற்றும் உச்சகட்ட பயன்பாடு இரண்டையும் காட்டும். ஒரு நேரத்தில் ஒரு பக்கத்தை மட்டும் வைத்து worker-ஐ இயக்கவும், உச்சகட்ட அளவைக் குறித்துக்கொள்ளவும். பிறகு இரண்டு பக்கங்களைத் திறந்து, இரண்டாவது பக்கத்திற்கு உண்மையில் எவ்வளவு செலவாகிறது என்று பார்க்கவும். Concurrency-ஐக் கணக்கிடுவது எளிது: மொத்த RAM-ல், machine-ன் பிற தேவைகளுக்குத் தேவையானதை நீக்கிவிட்டு, சில நூறு MB-ஐ ஒதுக்கி வைத்துவிட்டு, மீதமுள்ளதை ஒரு worker-க்குத் தேவைப்படும் உச்சகட்ட அளவால் வகுக்கவும். இதற்கான machine-ஐத் தேர்வு செய்ய, agent VPS-க்கு எவ்வளவு RAM மற்றும் CPU தேவை என்பதைப் பார்க்கவும்.
அந்த அளவை இரண்டு இடங்களில் அமல்படுத்தவும். உங்கள் code-ல், ஒரு நிலையான worker pool அல்லது semaphore-ஐப் பயன்படுத்தவும். இதனால், agent கோரிக்கைகள் ஒரே நேரத்தில் குவியும்போது, புதிய browser-களைத் தொடங்குவதற்குப் பதிலாக அவை வரிசையில் (queue) காத்திருக்கும். OS மட்டத்தில், cgroup limit-ஐப் பயன்படுத்தவும். இதனால், queue-ல் ஏதேனும் பிழை ஏற்பட்டால், அது முழு machine-ஐயும் முடக்காது:
[Service]
MemoryMax=2G
MemorySwapMax=0
TasksMax=512
Restart=alwaysMemorySwapMax=0 என்பது பார்ப்பதை விட முக்கியமானது. இது இல்லையென்றால், limit-ஐ நெருங்கும்போது cgroup பக்கங்களை swap-க்குத் தள்ள அனுமதிக்கும். இதனால், ஒவ்வொரு கோரிக்கையும் மெதுவாகச் செயல்படும், ஆனால் machine இயங்கிக்கொண்டிருக்கும். இது ஒரு முழுமையான தோல்வியை விடக் கண்டறிவதற்கு கடினமானது. Swap என்பது முடிவைத் தள்ளிப்போடும் மட்டுமே: systemd-ன் ஆவணங்கள் கூறுவது என்னவென்றால், பயன்பாடு "limit-க்குள் அடங்கவில்லை என்றால், unit-க்குள் out-of-memory killer தூண்டப்படும்". Swap பூஜ்ஜியமாக இருக்கும்போது, unit-ஆல் swap-ஐப் பயன்படுத்த முடியாது; MemoryMax-ஐ அடையும்போது, reclaim-ஆல் பயன்பாட்டைக் கட்டுப்படுத்த முடியாவிட்டால், OOM kill தூண்டப்படும். Restart=always அதன் முதன்மை process வெளியேறும்போது service-ஐ மீண்டும் தொடங்கும், ஆனால் ஒரு renderer மட்டும் OOM kill செய்யப்பட்டால் அது மீண்டும் தொடங்குவதை உறுதி செய்யாது. Compose-ல் இதற்கான கட்டுப்பாடுகள் mem_limit, shm_size மற்றும் init ஆகும், இவை Docker Compose-ல் memory limit அமைத்தல் என்பதில் விளக்கப்பட்டுள்ளன.
Browser endpoint-ஐ பொது இணையத்திலிருந்து விலக்கி வைத்தல்
Playwright-ஐ ஒரு server-ஆக இயக்கி, உங்கள் agent-க்கு ஒரு WebSocket URL-ஐ வழங்க முடியும்:
const { chromium } = require('playwright');
const server = await chromium.launchServer({ port: 3000 });
console.log(server.wsEndpoint());அந்த endpoint-க்கு login வசதி கிடையாது. Playwright-ன் API ஆவணங்கள் இதைத் தெளிவாகக் குறிப்பிடுகின்றன: "wsPath-ஐ அறிந்த எந்தவொரு process அல்லது web page-ம் (Playwright-ல் இயங்குபவை உட்பட) OS user-ன் கட்டுப்பாட்டைப் பெற முடியும்." இயல்பான host localhost ஆகும், இது "loopback interface-லிருந்து வரும் இணைப்புகளை மட்டுமே ஏற்கும்". 0.0.0.0 போன்ற ஒரு குறிப்பிட்ட முகவரியைக் குறிப்பிடுவது, "listening port-ஐ அணுகக்கூடிய எவருக்கும் browser RPC-ஐ வெளிப்படுத்திவிடும்" என்று ஆவணங்கள் எச்சரிக்கின்றன. Chrome-ன் சொந்த --remote-debugging-port இன்னும் மோசமானது. DevTools protocol-ல் எந்தவிதமான அங்கீகாரமும் (authentication) இல்லை; இது முழுமையாக loopback-ல் இணைக்கப்பட்டிருப்பதை மட்டுமே நம்பியுள்ளது.
நீங்கள் எதை public-ஆக வெளியிட்டுள்ளீர்கள் என்பதைச் சரிபார்க்கவும். இதை உங்கள் VPS-லிருந்து மட்டுமல்லாமல், மற்றொரு கணினியிலிருந்தும் சரிபார்க்கவும்:
ss -ltnp0.0.0.0-ல் இணைக்கப்பட்டிருக்கும் எந்தவொரு browser port-ம் ஒரு பாதுகாப்பு குறைபாடாகும் (finding). பெரும்பாலான சேவை வழங்குநர்கள் தங்கள் control panel-ல் தனிப்பட்ட network firewall-ஐ இயக்குகிறார்கள் என்பதை நினைவில் கொள்க. உங்கள் ufw விதிகள் இதைப் பற்றி அறியாது. அதற்குப் பதிலாக, SSH tunnel அல்லது private VPN வழியாக மற்றொரு கணினியிலிருந்து அந்த endpoint-ஐ அணுகவும்:
ssh -N -L 3000:127.0.0.1:3000 you@your-vpsஇங்குள்ள ஆபத்து, browser-ன் நேரத்தைத் திருடுவதை விடப் பெரியது. நீங்கள் இயக்கக்கூடிய ஒரு browser, உங்கள் network-க்குள் இருக்கும் ஒரு request-forgery கருவியாகும். அந்த socket-ஐ அணுகும் எவரும், அதைக்கொண்டு http://127.0.0.1:8080, உங்கள் database admin பக்கம் அல்லது 169.254.169.254-ல் உள்ள cloud metadata முகவரியை fetch செய்து, அந்தப் பக்கத்திலிருந்து பதிலை வாசிக்க முடியும். உங்கள் firewall, அந்த request VPS-லிருந்தே வருவதாகக் கருதும், எனவே அது அனுமதிக்கப்படும். அந்த control endpoint-ஐ, அந்த box-ல் shell access பெற்றதற்குச் சமமாகக் கருதவும்.
MCP server-களும் இதே தன்மையைக் கொண்டவை. npx @playwright/mcp@latest --headless --port 8931, localhost-ல் HTTP வழியாகச் செயல்படுகிறது. --host 0.0.0.0 என்பது ஒரு local tool-ஐ public tool-ஆக மாற்றும் flag ஆகும். Playwright MCP "ஒரு பாதுகாப்பு எல்லை (security boundary) அல்ல" என்று அந்தத் திட்டத்தின் README தெளிவாகக் கூறுகிறது. அந்த port-ஐ loopback-லேயே வைத்திருக்கவும், அதே tunnel வழியாக agent-ஐ அதை அணுக அனுமதிக்கவும்.
உங்கள் agent வாசிக்கும் பக்கங்கள் நம்பகத்தன்மையற்ற உள்ளீடுகள்
திறந்த இணையதளத்தில் உலாவரும் ஒரு agent, அந்நியர்கள் எழுதிய உரையை உங்கள் அறிவுறுத்தல்கள் இருக்கும் அதே model-க்கு உள்ளீடாக வழங்குகிறது. ஒரு இணையப்பக்கம் அந்த model-ஐக் குறிவைத்து, கொடுக்கப்பட்ட பணியைக் கைவிடுமாறும், ஒரு கருவியை (tool) இயக்குமாறும், அல்லது ஒரு URL-க்குத் தரவுகளைப் பதிவேற்றுமாறும் கட்டளையிடலாம். Model இந்த இரண்டையும் உரையாகவே பெறுவதால், பக்கத்தில் உள்ள சொற்களுக்கும் உங்களுடைய அறிவுறுத்தல்களுக்கும் இடையே உள்ள வேறுபாட்டை அதனால் நம்பகத்தன்மையுடன் கண்டறிய முடியாது. எனவே, ஒரு தீங்கிழைக்கும் பக்கம் செயல்பட முடியாதபடி உங்கள் அமைப்பை வடிவமைக்கவும்.
- Browser-ஐ அதற்கென ஒதுக்கப்பட்ட தனி OS user-ன் கீழ் இயக்கவும்; அதன் சூழலில் SSH keys அல்லது cloud credentials எதையும் வைத்திருக்க வேண்டாம்.
- ஒவ்வொரு பணிக்கும் புதிய context-ஐப் பயன்படுத்தவும், மேலும் Playwright MCP உடன்
--isolated-ஐப் பயன்படுத்தவும்; அந்த session-ன் சேமிப்பகத்தை நீக்க, பணிகளுக்கு இடையே MCP browser-ஐ மூடிவிடவும். - பணி அனுமதிக்கும் இடங்களில், ஒரு origin allowlist-ஐப் பராமரிக்கவும். Playwright MCP,
--allowed-originsமற்றும்--blocked-originsஆகியவற்றை அரைப்புள்ளி (semicolon) மூலம் பிரிக்கப்பட்ட பட்டியல்களாக எடுத்துக்கொள்கிறது. இந்த வடிகட்டிகள் (filters) வழிமாற்றுகளை (redirects) பாதிக்காது, மேலும் இவை ஒரு பாதுகாப்பு எல்லையாகவும் (security boundary) கருதப்படாது. - மின்னஞ்சல் அனுப்புதல் அல்லது பணம் செலவழித்தல் போன்ற, நிலையை மாற்றக்கூடிய எந்தவொரு செயலுக்கும் முன்னதாக மனிதரின் ஒப்புதலைக் கட்டாயமாக்கவும்.
இதைவிடச் சிறந்தது, முழு browser-ஐயும் நீங்கள் அழித்துவிட்டு மீண்டும் உருவாக்கக்கூடிய ஒரு கணினியில் வைத்திருப்பதுதான்; இது coding agents-ஐ ஒரு disposable VM-ல் இயக்குவது போன்ற அதே வாதமாகும். Agent-ன் உண்மையான பணி பொதுவான உலாவல் அல்லாமல் தேடல் மட்டுமே என்றால், முழுமையான browser-ஐ விடக் குறுகிய செயல்பாடுகளைக் கொண்ட கருவியே பாதுகாப்பானது: உங்கள் சொந்த SearXNG மூலம் இயங்கும் ஒரு தேடல் திறன், தீங்கிழைக்கும் பக்கங்களை ஏற்றாமலேயே முடிவுகளைத் தரும்.
FAQ
Chromium ஏன் Docker-ல் செயலிழக்கிறது, ஆனால் அதே VPS-ல் நேரடியாக இயங்கும்போது சரியாகச் செயல்படுகிறது?
ஏனெனில், container இயல்பாகவே 64 MB /dev/shm-ஐப் பெறுகிறது, ஆனால் host கணினியில் அதைவிட அதிக அளவு உள்ளது. Chromium தான் ரெண்டர் செய்த உள்ளடக்கத்தை அந்த பகிரப்பட்ட நினைவகப் பகுதி வழியாக அனுப்புகிறது, எனவே ஒரு கனமான பக்கம் அதை நிரப்பும்போது renderer செயலிழந்துவிடும். இதை உறுதிப்படுத்த container-க்குள் df -h /dev/shm-ஐ இயக்கவும். பின்னர், host-ன் பகிரப்பட்ட நினைவகத்தைப் பயன்படுத்தும் --ipc=host அல்லது container-ன் சொந்த நினைவகத்தை அதிகரிக்கும் --shm-size=1g ஆகியவற்றில் ஒன்றைப் பயன்படுத்தித் தொடங்கவும். --disable-dev-shm-usage என்பது சிக்கலை /tmp-க்கு மட்டுமே மாற்றும். Playwright 1.62 அந்த flag-ஐ இயல்பாகவே அனுப்புகிறது; நீங்கள் ஒதுக்கிய பகிரப்பட்ட நினைவகத்தைப் பயன்படுத்த Chromium-ஐச் செய்ய ignoreDefaultArgs: ['--disable-dev-shm-usage']-ஐப் பயன்படுத்தவும்.
VPS-ல் வேறு எதுவும் இயங்கவில்லை என்றால் --no-sandbox பாதுகாப்பானதா?
இல்லை. ஒரு தீங்கிழைக்கும் பக்கம் கணினியின் பிற பகுதிகளுக்குச் செல்வதைத் தடுப்பதே sandbox ஆகும். இந்த flag குறித்து Chromium-ன் பாதுகாப்புப் பக்கங்கள் இவ்வாறு கூறுகின்றன: "இது உங்கள் பாதுகாப்பைக் கணிசமாகக் குறைக்கும் மற்றும் Chromium சரியாகச் செயல்படுவதைத் தடுக்கக்கூடும் என்பதால், இதை நாங்கள் ஊக்குவிப்பதில்லை." இணைப்புகளைப் பின்தொடரும் ஒரு agent திறந்த இணையத்தில் உலாவுகிறது. அதற்குப் பதிலாகக் காரணத்தைச் சரிசெய்யவும்: browser-ஐ root பயனராக இயக்க வேண்டாம். Ubuntu 24.04-ல், browser binary பாதைக்கு userns,-ஐக் கொண்ட AppArmor profile-ஐச் சேர்க்கவும், இதன் மூலம் அந்த ஒரு நிரலுக்கு மட்டும் unprivileged user namespaces அனுமதிக்கப்படும். chromiumSandbox: true மூலம் sandboxing-ஐ வெளிப்படையாக இயக்கவும்; Docker-ல், Playwright பரிந்துரைக்கும் seccomp profile-ஐயும் பயன்படுத்தவும்.
ஒரு சிறிய VPS-ல் எத்தனை browser-களை என்னால் இயக்க முடியும்?
அளவீடு செய்யுங்கள், ஒரு எண்ணை நகலெடுக்க வேண்டாம். Chromium ஒரு தளத்திற்கு ஒரு renderer process-ஐத் தொடங்குகிறது, எனவே நீங்கள் திறக்கும் பக்கங்களைப் பொறுத்தே விடை அமையும். MemoryMax அமைக்கப்பட்ட நிலையில் systemd-run-ன் கீழ் ஒரு worker-ஐ இயக்கவும், systemctl status-ல் உள்ள Memory: வரியிலிருந்து உச்ச அளவை (peak) வாசிக்கவும். பின்னர், உங்கள் இலவச RAM-ஐ அந்த உச்ச அளவால் வகுத்து, கூடுதல் இடவசதியை (headroom) வைத்துக்கொள்ளவும். உங்கள் குறியீட்டில் ஒரு queue மற்றும் unit file-ல் ஒரு MemoryMax ஆகியவற்றை வைத்து இந்த முடிவை இருமுறை அமல்படுத்தவும், இதனால் கோரிக்கைகளின் திடீர் அதிகரிப்பு கணினியை swap செய்யாமல் காத்திருக்கும்.
எனது agent மற்றொரு கணினியிலிருந்து browser-உடன் இணைய முடியுமா?
ஆம், ஆனால் port-ஐ ஒருபோதும் 0.0.0.0-ல் bind செய்ய வேண்டாம். Playwright server endpoint மற்றும் Chrome DevTools port ஆகிய இரண்டுமே அதை அணுகக்கூடிய எந்தவொரு client-ஐயும் கடவுச்சொல் இன்றி ஏற்றுக்கொள்ளும். listener-ஐ 127.0.0.1-ல் வைத்திருக்கவும், SSH tunnel அல்லது private VPN வழியாக இணைப்பை மேற்கொள்ளவும். server-ல் ss -ltnp மூலமும், வெளியிலிருந்து port check மூலமும் சரிபார்க்கவும், மேலும் உங்கள் சேவை வழங்குநரின் தனிப்பட்ட network firewall-ஐயும் கவனிக்கவும்.
பக்கம் தெளிவாக ஏற்றப்பட்டிருந்தும் எனது screenshots ஏன் காலியாக உள்ளன?
எழுத்துருக்கள் (fonts) விடுபட்டுள்ளன. பக்கத்தின் script-க்குத் தேவையான எழுத்துரு இல்லாதபோது, உரை காலியான பெட்டிகளாக அல்லது எதுவுமே இல்லாமலோ காட்சியளிக்கும், எனவே படம் குறைவாக உள்ள பக்கம் காலியாகத் தெரியும். நீங்கள் scrape செய்யும் ஒவ்வொரு மொழிக்கும் fc-match "sans-serif:lang=ko"-ஐ இயக்கவும், விடை பொதுவான fallback-ஆக இருக்கும்போது fonts-noto-core மற்றும் fonts-noto-cjk-ஐ நிறுவவும், fontconfig அதன் cache-ஐ மீண்டும் ஏற்ற browser-ஐ மறுதொடக்கம் செய்யவும். எழுத்துருக்கள் இல்லாத ஒரு container தொடக்கத்தின்போது Fontconfig error: Cannot load default config file-ஐப் பதிவு செய்யும்.