SSD Nodes Learn Hosting plans →
கல்வி வழிகாட்டிகள் Matt Connorஆல் Matt Connor · புதுப்பிக்கப்பட்டது 2026-10-24

VPS-ல் open-kritt-ஐ self-host செய்வது எப்படி?

Docker Compose மூலம் open-kritt-ஐ VPS-ல் நிறுவும் முறை, release pinning, port 5173 SSH tunnel மற்றும் முதல் scan-க்கு முன் கவனிக்க வேண்டிய provider budget விவரங்களை அறியுங்கள்.

உங்கள் மடிக்கணினியில் அல்லாமல், ஏன் ஒரு VPS-ல் open-kritt-ஐ self-host செய்ய வேண்டும்

நீங்கள் அழித்து மீண்டும் உருவாக்கக்கூடிய ஒரு server-ல் open-kritt-ஐ self-host செய்யுங்கள். இந்த கருவி தனது analysis agents-ஐ root பயனர் உரிமையுடன் தற்காலிக job containers-க்குள் இயக்குகிறது. இது ஒவ்வொரு agent-க்கும் உங்கள் குறியீட்டின் (code) ஒரு writable நகலையும், நேரடி இணைய அணுகலையும் வழங்குகிறது, மேலும் host Docker socket-ஐ அதன் engine service-ல் mount செய்கிறது. இந்த பணிக்காகவே ஒதுக்கப்பட்ட ஒரு கணினியில் இது ஏற்றுக்கொள்ளக்கூடிய ஒரு சமரசம். ஆனால், உங்கள் SSH keys இருக்கும் கணினியில் இது ஆபத்தானது.

இயல்புநிலை அமைப்பின் நான்கு பண்புகள் இந்த ஆலோசனையை வலியுறுத்துகின்றன. இவை அனைத்தும் அந்த திட்டத்தின் சொந்த README மற்றும் compose கோப்பிலிருந்து பெறப்பட்டவை.

Agents அதிக சக்தி வாய்ந்தவை. README-ன் படி, tool-enabled agents root உரிமையுடன் தற்காலிக job containers-க்குள் இயங்குகின்றன. அவற்றுக்கு writable repository நகல்களும் நேரடி இணைய அணுகலும் இருப்பதால், அவற்றால் கருவிகளை நிறுவவும், இலக்குகளை compile செய்யவும், சோதனைகளை இயக்கவும், proofs of concept-ஐ உருவாக்கவும் முடியும். ஒரு scan என்பது கோப்புகளை வாசிக்கும் linter அல்ல. இது நீங்கள் கோரிய தன்னிச்சையான குறியீடு செயலாக்கம் (arbitrary code execution). அந்த இணைய அணுகல் இருபுறமும் பாதிப்பை ஏற்படுத்தும்: ஒரு agent இலக்கைப் பற்றி ஆய்வு செய்யும்போது பதிவிறக்கும் எதுவும் அதன் prompt-க்குள் வரும் நம்பகத்தன்மையற்ற உரையாகும். இது நீங்கள் ஒரு agent-க்கு இணையத் தேடல் வசதியை அளிக்கும்போது ஏற்படும் அதே ஆபத்தாகும்.

Engine-ஆனது Docker socket-ஐக் கொண்டுள்ளது. docker-compose.yml host Docker socket-ஐ engine service-க்குள் mount செய்கிறது, ஏனெனில் engine ஒவ்வொரு பணிக்கும் ஒரு scan container-ஐ உருவாக்கி இயக்குகிறது. அந்த socket-ஐ அணுகக்கூடிய எந்தவொரு process-ம், host filesystem-ஐ mount செய்யும் ஒரு container-ஐத் தொடங்க முடியும். எனவே, engine எந்த host-ல் இயங்குகிறதோ, அந்த host-ன் root உரிமையை அது உண்மையில் பெற்றுள்ளது.

Login திரை இல்லை. இந்த backend எந்தவொரு application authentication வசதியும் இன்றி வருகிறது. அந்த port-ஐ அணுகுவது என்பது உங்கள் கண்டுபிடிப்புகளையும், உங்கள் provider credit-ஐயும் அணுகுவதற்கு சமம்.

நீங்கள் ஸ்கேன் செய்யும் குறியீடு பெரும்பாலும் உங்களுடையது அல்ல. மூன்றாம் தரப்பு repository-களை agents-க்குக் காட்டுவது என்பது, அந்த repository-ன் build-ஐ உங்கள் கணினியில், root உரிமையுடன், இணைய அணுகலுடன் இயக்குவதாகும்.

நீங்கள் coding agents ஏன் தற்காலிக VM-ல் இருக்க வேண்டும் என்பதைப் படித்திருந்தால், இது அதே அச்சுறுத்தல் மாதிரிதான், ஆனால் இன்னும் தீவிரமானது. open-kritt-க்கு வேறு எதுவும் இல்லாத ஒரு VPS-ஐ ஒதுக்குங்கள், மேலும் அந்த VPS-ஐ root-க்கு பதிலாக ஒரு தனிப்பட்ட குறைந்தபட்ச உரிமை கொண்ட பயனர் கணக்கிலிருந்து இயக்குங்கள்.

open-kritt உண்மையில் என்ன செய்கிறது

open-kritt (இதன் repository Kritt-ai/open-kritt, உரிமம் AGPL-3.0) பாதிப்பு குறித்த ஆராய்ச்சியைச் சிறிய பணிகளாகப் பிரிக்கிறது. இந்தப் பணிகளை AI agents மூலம் இணையாக (parallel) இயக்குகிறது. பின்னர், கிடைக்கும் முடிவுகளைத் தேவையற்ற நகல்களை நீக்கி (de-duplicate) வரிசைப்படுத்துகிறது. நீங்கள் ஒரு workflow-ஐக் குறிப்பிட்ட prompts-களின் சங்கிலியாக வரையறுக்கிறீர்கள். ஒவ்வொரு படியும் அதற்கு முந்தைய படிகளிலிருந்து கட்டமைக்கப்பட்ட சூழலைப் (structured context) பெறுகிறது. ஸ்கேன் இலக்கு என்பது ஒரு remote அல்லது local git repository ஆகும். இதற்கான analysis engine-ஆக Codex அல்லது Claude Code செயல்படுகிறது. ஒரு candidate கண்டறியப்பட்ட பிறகு, விருப்பத்தேர்வாக உள்ள post-scripts மூலம் அதைச் சரிபார்க்கவோ அல்லது proof of concept-ஐ உருவாக்கவோ முடியும். அந்தச் சங்கிலியை வடிவமைப்பது என்பது பாதுகாப்பு சார்ந்த பணியை விட, சாதாரண agent சார்ந்த பணியாகும். எனவே, prompts, tools மற்றும் context passing ஆகியவை உங்களுக்குப் புதியதாக இருந்தால், agents எவ்வாறு கட்டமைக்கப்படுகின்றன என்பதைக் கற்றுக்கொள்வது இந்த வழிகாட்டியில் உள்ள எந்தவொரு அமைப்பை விடவும் சிறந்த முடிவுகளைத் தரும்.

இறுதியில் உங்களுக்குக் கிடைப்பது வரிசைப்படுத்தப்பட்ட candidates பட்டியல் மட்டுமே. இதை ஒரு முழுமையான அறிக்கை (report) என்று கருதாமல், வகைப்படுத்தும் வரிசையாக (triage queue) அணுகுங்கள்.

தொடங்குவதற்கு முன் உங்களுக்குத் தேவையானவை

  • Ubuntu 24.04, Debian 12 அல்லது Rocky Linux 9 இயங்கும் ஒரு VPS. x86_64 மற்றும் ARM64 கட்டமைப்புகளில் இவை சோதிக்கப்பட்ட விநியோகங்கள் என நிறுவல் ஆவணங்கள் குறிப்பிடுகின்றன.
  • Compose plugin உடன் கூடிய Docker Engine.
  • host-ல் Node.js 20 அல்லது அதற்குப் பிந்தைய பதிப்பு. ஏனெனில் ./kritt CLI ஆனது container-க்குள் இல்லாமல் host-லேயே இயங்குகிறது.
  • ஏதேனும் ஒரு model provider: ஒரு Codex login, அல்லது OPENAI_API_KEY, CODEX_API_KEY, ANTHROPIC_API_KEY அல்லது OPENROUTER_API_KEY.
  • நீங்கள் private repositories-ஐ ஸ்கேன் செய்யத் திட்டமிட்டால் மட்டுமே GITHUB_TOKEN தேவை. வழங்கப்பட்ட .env.example இதைத் தெளிவாகக் குறிப்பிடுகிறது: ஒரு GitHub token-ஐ மட்டும் வைத்துக்கொண்டு ஸ்கேன்களை இயக்க முடியாது.

Docker மற்றும் Node 20-ஐ முதலில் நிறுவுதல்

curl -fsSL https://get.docker.com | sudo sh
sudo usermod -aG docker $USER

புதிய group membership நடைமுறைக்கு வர, log out செய்து மீண்டும் log in செய்யவும். அதன் பிறகு Compose plugin இருப்பதை உறுதிப்படுத்தவும்.

docker compose version

ஒரு version string காட்டப்பட்டால், Compose ஒரு plugin-ஆக நிறுவப்பட்டுள்ளது என்று அர்த்தம். docker: 'compose' is not a docker command என்று காட்டப்பட்டால், உங்களிடம் பழைய standalone docker-compose binary உள்ளது என்று பொருள்; open-kritt, docker compose-ஐ அழைக்கிறது. docker group-ல் உறுப்பினராக இருப்பது host-ல் root-க்கு சமமானது, எனவே open-kritt-ஐ இயக்கும் account-ஐ மட்டும் அதில் சேர்க்கவும். அந்த அமைப்பைப் பற்றிய விரிவான தகவலுக்கு, VPS-ல் Docker-ஐ இயக்குதல் என்பதைப் பார்க்கவும்.

Ubuntu 24.04 அதன் சொந்த repository-ல் Node 18-ஐ வழங்குகிறது, ஆனால் CLI 20-க்குக் கீழ் உள்ள எதற்கும் இயங்காது. Node 20 தற்போது அதன் ஆயுட்காலத்தை (end of life) எட்டிவிட்டது, அதற்கு இனி updates கிடைக்காது. எனவே, NodeSource-லிருந்து Node 22-ஐ நிறுவவும். இது 20 அல்லது அதற்கு மேற்பட்ட பதிப்பு தேவை என்ற நிபந்தனையைப் பூர்த்தி செய்யும்.

curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt install -y nodejs
node -v

node -v இங்கே v22. என்று காட்ட வேண்டும். v20.-க்குக் கீழ் உள்ள எதையும் CLI நிராகரித்துவிடும். Rocky Linux 9-ல் இதற்கு இணையான செயல்முறை sudo dnf module enable nodejs:22 -y மற்றும் அதைத் தொடர்ந்து sudo dnf install -y nodejs ஆகும்.

open-kritt-ஐ clone செய்து ஒரு குறிப்பிட்ட tagged release-ஐ pin செய்தல்

git clone https://github.com/Kritt-ai/open-kritt
cd open-kritt
git fetch --tags
git tag --list
git checkout v1.4.1

main உங்களுக்குக் கீழே நகரும். ஆனால் ஒரு tag நகராது. 12 October 2026 நிலவரப்படி, புதிய tag v1.4.1 ஆகும், இது 16 August 2026 அன்று வெளியிடப்பட்டது. நீங்கள் clone செய்யும் நாளில் என்ன இருக்கிறது என்பதை git tag --list காட்டுகிறது. v1.4.0 (12 August 2026) பதிப்பில், கீழே உள்ள sizing பகுதியில் விவரிக்கப்பட்டுள்ள memory-aware runner admission சேர்க்கப்பட்டது. v1.4.1 பதிப்பில், பயனர் வழங்கிய ranking விதிகளை ranker புறக்கணித்த பிழை சரிசெய்யப்பட்டது. ஒரு tag-ஐ checkout செய்யும்போது, repository detached HEAD நிலையில் இருக்கும்; இது சரியானதே. நீங்கள் இந்த clone-ஐ ஒரு pinned deployment-ஆகவே கருதுகிறீர்கள், நீங்கள் commit செய்யும் branch-ஆக அல்ல. பிற்காலத்தில் upgrade செய்ய, release notes-ஐப் படித்துவிட்டு, git fetch --tags-ஐ இயக்கி, புதிய tag-ஐ checkout செய்து, மீண்டும் ./kritt start-ஐ இயக்கவும். ஏனெனில் start images-ஐ மீண்டும் கட்டமைக்கும் (rebuild).

./kritt-ஐ sudo உடன் இயக்க வேண்டாம். ஆவணங்கள் இதைப் பற்றி தெளிவாகக் குறிப்பிடுகின்றன. CLI ஆனது .data/-க்குக் கீழ் உள்ள project-local credential directories-ஐ நிர்வகிக்கிறது. எனவே, root பயனராக இயக்கினால், அந்த directories-ன் உரிமை root-க்குச் சென்றுவிடும். அதன் பிறகு சாதாரண பயனர் அதை எழுத முடியாது.

./kritt setup மூலம் model access-ஐ உள்ளமைத்தல்

./kritt setup

இந்தக் கட்டளை .env.example கோப்பு இல்லாதபோது அதிலிருந்து .env-ஐ உருவாக்குகிறது, ஒவ்வொரு credential-ன் நிலையையும் அச்சிடுகிறது, மேலும் அவற்றை அமைக்க அல்லது நீக்க அனுமதிக்கிறது. இது எந்தவொரு மதிப்பையும் terminal-ல் மீண்டும் அச்சிடுவதில்லை. .env மற்றும் engine credential கோப்பு ஆகிய இரண்டுமே 0600 mode-ல் எழுதப்படுகின்றன.

நீங்கள் இதை நீங்களே செய்ய விரும்பினால்:

cp .env.example .env
chmod 600 .env
mkdir -p .data/codex
chmod 700 .data/codex

பின்னர் .env கோப்பில் provider key-ஐ உள்ளிடவும், அந்தக் கோப்பை 0600 அனுமதியிலேயே வைத்திருக்கவும். எப்படிச் செய்தாலும், இப்போது அந்த server-ல் ஒரு செயல்படும் provider credential உள்ளது; அந்த server-ல் வேறு எதையும் வைத்திருக்கக்கூடாது என்பதற்கு இதுவும் ஒரு காரணம். இந்தத் திட்டத்திற்காக மட்டும் ஒரு தனி key-ஐ உருவாக்கவும், அப்போதுதான் அதைத் திரும்பப் பெறும்போது நீங்கள் முக்கியமாகக் கருதும் பிற சேவைகள் பாதிக்கப்படாது. AI agents-க்கு எட்டாதவாறு ரகசியங்களைப் பாதுகாத்தல் என்ற பகுதி இது குறித்த விரிவான பழக்கவழக்கங்களை விளக்குகிறது.

முதல் ஸ்கேனுக்கு முன்பே provider spending cap-ஐ அமைக்கவும்

open-kritt என்பது fan-out முறையில் செயல்படும் வகையில் உருவாக்கப்பட்டுள்ளது, இந்த fan-out செயல்பாட்டிற்கே நீங்கள் கட்டணம் செலுத்துகிறீர்கள். v1.4.1-ல் .env.example-ன் இயல்புநிலை அமைப்புகள் கவனமாக வைக்கப்பட்டுள்ளன: ENGINE_WORKER_COUNT=2, இது சிறிய 2-vCPU இயந்திரத்திற்கான பாதுகாப்பான இயல்புநிலையாகக் கோப்பில் விவரிக்கப்பட்டுள்ளது, மற்றும் ENGINE_MAX_CONCURRENT_SCANS=1. இவற்றுக்கு மேலே ENGINE_WORKERS_PER_ACCOUNT=15 உள்ளது, இது ஒரு provider கணக்கில் அனுமதிக்கப்படும் அதிகபட்ச concurrent root model calls ஆகும், மேலும் ENGINE_CODEX_MAX_SUBAGENTS_PER_SESSION=5 உள்ளது, ஏனெனில் ஒரு Codex session ஐந்து child agents வரை இயக்கக்கூடும். பெரிய VPS-ல் worker எண்ணிக்கையை அதிகரித்தால், ஒரே நேரத்தில் இயங்கும் model calls-ன் எண்ணிக்கையும் அதற்கேற்ப உயரும்.

Repository-ல் நீங்கள் எவ்வளவு செலவு செய்கிறீர்கள் என்பதைக் கட்டுப்படுத்தும் வசதி எதுவும் இல்லை. .env.example-ல் budget அமைப்புகள் எதுவும் இல்லை. இந்த engine-ன் சொந்த stop conditions என்பவை அந்த worker வரம்புகள் மற்றும் ENGINE_HARNESS_TIMEOUT_SECONDS மட்டுமே, இது ஒரு harness run-க்கு 7200 வினாடிகள் என இயல்புநிலையாக உள்ளது. இங்கே harness என்பது, ஏதேனும் ஒன்று run-ஐ முடிக்கும் வரை tools மற்றும் context-உடன் model-ஐத் தொடர்ந்து அழைக்கும் ஒரு loop ஆகும், எனவே அந்த timeout என்பது model-ஐச் சுற்றியுள்ள நிரலின் நேரத்தைக் குறிக்குமே தவிர, model உள்ளே செலவிடும் தொகையை அல்ல. எனவே, செலவு வரம்பை provider தளத்திலேயே அமைக்க வேண்டும். உங்கள் provider console-ஐத் திறந்து, முதல் ஸ்கேனுக்குப் பிறகு அல்ல, அதற்கு முன்பே ஒரு hard monthly limit-ஐ அமைக்கவும். VPS-ல் AI agent-ன் செலவைக் கட்டுப்படுத்துதல் என்ற கட்டுரை ஒவ்வொரு provider-க்கும் உரிய அமைப்புகளை விளக்குகிறது.

உள்ளூர் அளவில் ஒரு தடுப்பு வசதியும் உள்ளது. ENGINE_WORKER_COUNT=0-ஐ அமைப்பதன் மூலம் புதிய வேலைகளை எடுப்பது நிறுத்தப்படும், மேலும் stack இயங்கத் தொடங்கிய பிறகு Settings திரையில் அதே worker மதிப்புகளை மாற்றிக்கொள்ளலாம்.

இந்த வழிகாட்டி ஒரு ஸ்கேனுக்கான விலையை எங்கும் குறிப்பிடவில்லை, ஏனெனில் செலவு என்பது repository-ன் அளவு, நீங்கள் உருவாக்கும் workflow மற்றும் அதன் பின்னால் உள்ள model ஆகியவற்றைப் பொறுத்தது. ஒரு சிறிய repository-ல் ஒரு ஸ்கேனை இயக்கிவிட்டு, பெரிய எதிலாவது பயன்படுத்துவதற்கு முன்பு உங்கள் provider-ன் usage பக்கத்தைப் பார்க்கவும்.

Stack-ஐத் தொடங்கி அதன் ஆரோக்கியத்தைச் சரிபார்த்தல்

./kritt start

இது .env மற்றும் குறைந்தபட்சம் ஒரு credential-ஐச் சரிபார்த்து, பின் docker compose up --build-ஐ இயக்குகிறது. முதல் build மெதுவாக இருக்கும், ஏனெனில் இது frontend, backend, engine, executor view மற்றும் database images ஆகியவற்றை உருவாக்குகிறது. இது foreground-ல் இயங்குவதால், SSH session-ஐ மூடினால் stack நின்றுவிடும். இதை tmux-க்குள் தொடங்கவும், அல்லது முதல் build வெற்றிகரமாக முடிந்ததும் detached முறையில் இயக்கவும். இவை எதுவுமே reboot-க்கு பின் தானாக இயங்காது, எனவே server restart ஆன பிறகும் stack இயங்க வேண்டுமெனில், keeping a self-hosted agent running across reboots-ல் உள்ள systemd unit முறையைப் பயன்படுத்தலாம்.

docker compose up -d --build
docker compose ps

docker compose ps கட்டளையிட்டால் open-kritt-frontend, open-kritt-backend, open-kritt-engine, open-kritt-executor-view மற்றும் open-kritt-db ஆகியவற்றை பட்டியலிட வேண்டும். பின் backend server-லேயே பதிலளிக்கிறதா என்று சரிபார்க்கவும்.

curl -s http://127.0.0.1:3002/api/health

JSON response கிடைத்தால் backend இயங்குகிறது என்று அர்த்தம். Failed to connect to 127.0.0.1 port 3002: Connection refused என்றால் அது இயங்கவில்லை என்று பொருள், docker compose logs backend அதற்கான காரணத்தைக் கூறும். repository directory-ல் இருந்து docker compose down மூலம் அனைத்தையும் நிறுத்தவும்.

கூடுதல் விருப்பம்: docker compose exec backend npm run seed demo தரவுகளை ஏற்றும், இது உண்மையான scan-க்கு செலவு செய்வதற்கு முன் interface-ஐப் பார்க்க எளிதான வழியாகும்.

SSH tunnel மூலம் port 5173-ல் UI-ஐ அணுகுதல்

Compose கோப்பில் உள்ள ஒவ்வொரு சேவையும் இயல்பாகவே 127.0.0.1-ல் இணைகிறது: frontend 5173-லும், backend 3002-லும், executor view 8090-லும், Postgres 5432-லும் இயங்குகின்றன. அந்த இணைப்புகளை மாற்ற வேண்டாம்; அதற்குப் பதிலாக உங்கள் கணினியிலிருந்து SSH மூலம் அந்த port-ஐ forward செய்யவும்.

ssh -N -L 5173:127.0.0.1:5173 you@your-server-ip

அந்த command இயங்கிக்கொண்டிருக்கும்போது, உங்கள் உள்ளூர் browser-ல் http://localhost:5173-ஐத் திறக்கவும். -N என்பது அந்த இணைப்பில் shell இல்லாமல் port forwarding மட்டும் நடப்பதைக் குறிக்கிறது. உங்களுக்கு executor view-ம் தேவைப்பட்டால், அதே command-ல் இரண்டாவது -L 8090:127.0.0.1:8090-ஐச் சேர்க்கவும்.

SSH tunnel-ஐத் தவிர்த்துவிட்டு FRONTEND_BIND_ADDRESS=0.0.0.0-ஐ அமைப்பது எளிதாகத் தோன்றலாம். ஆனால் அதைச் செய்ய வேண்டாம். Backend-ல் login திரை இல்லை; எனவே அந்தப் பக்கத்தை அணுகும் எவரும் ஸ்கேன்களைத் தொடங்கி உங்கள் provider credit-ஐப் பயன்படுத்த முடியும். இதற்கு மாறாக, Vaultwarden இணையத்தில் நேரடியாகச் செயல்படும் வகையில் வடிவமைக்கப்பட்டுள்ளது, மேலும் அதை வலுப்படுத்துவது அதன் admin token மற்றும் backup கோப்பைப் பொறுத்தது, ஆனால் open-kritt அத்தகைய பாதுகாப்பு வசதிகளை வழங்குவதில்லை. இதில் மற்றொரு ஆபத்தும் உள்ளது: ஒரு container port-ஐ வெளியிடும்போது, அது ufw-ன் இயல்புநிலை கொள்கைக்கு முன்பே கையாளப்படுகிறது, எனவே ஒரு ufw deny 5173 விதி சரியாகத் தெரிந்தாலும் அது எதையும் தடுப்பதில்லை. Docker ports that bypass ufw என்பது இதற்குக் காரணமான rule chain-ஐ விளக்குகிறது.

VPS-ன் அளவை நிர்ணயித்தல்

ENGINE_MIN_FREE_STORAGE_GB இயல்பாக 20 என அமைக்கப்பட்டுள்ளது. காலியான சேமிப்பகம் (free storage) இந்த அளவை விடக் குறையும் போது, புதிய per-job scan container-ஐத் தொடங்க engine மறுத்துவிடும். உருவாக்கப்பட்ட images, checkout cache, Postgres தரவுகள் மற்றும் job workspaces ஆகிய அனைத்தும் ஒரே வட்டில் (disk) இருப்பதால், 20 GB அளவுள்ள VPS-ல் ஸ்கேன் தொடங்கவே செய்யாது. குறைந்தபட்சம் 40 GB சேமிப்பகத்தை அடிப்படையாகக் கொள்ளுங்கள்; பெரிய repositories-ஐ ஸ்கேன் செய்வதாக இருந்தால் கூடுதல் சேமிப்பகம் தேவைப்படும். சேமிப்பகத்தை அதிகம் பயன்படுத்தும் பிற சேவைகளை இதனுடன் சேர்த்து நிறுவி சேமிப்பகத்தை வீணாக்காதீர்கள். PhotoPrism மற்றும் Immich ஒப்பீட்டில் காட்டப்பட்டுள்ள RAM மற்றும் வட்டு பயன்பாட்டு அளவுகள், ஒரு media library ஸ்கேனிங்கிற்குத் தேவையான இடத்தைப் எவ்வளவு விரைவாக ஆக்கிரமிக்கும் என்பதைக் காட்டுகின்றன. ஸ்கேனருடன் ஒப்பிடும்போது சிறியதாகத் தோன்றும் கூடுதல் மென்பொருட்களுக்கும் இது பொருந்தும்: Jellyfin library-ஐ 90-களின் வாடகை கடை போல மாற்றும் browser front end, ஒரு முழுமையான media server-ஐயும் அதன் transcodes-ஐயும் வட்டில் சேர்க்கும். எனவே, அத்தகைய சேவைகளை வேறு host-ல் நிறுவுங்கள்.

நினைவகத்தின் (Memory) அளவு எளிய கணக்கீட்டைப் பொறுத்தது. இதற்கான அமைப்புகள் v1.4.0 பதிப்பில் அறிமுகப்படுத்தப்பட்டன, எனவே இவை மேலே குறிப்பிடப்பட்ட tag-க்கு மட்டுமே பொருந்தும், பழைய பதிப்புகளுக்கு அல்ல. ENGINE_MEMORY_RESERVE_GB=2 என்பது engine, database, API மற்றும் இதர குறுகிய கால செயல்பாடுகளுக்காக ஒதுக்கப்பட்ட நினைவகமாகும். ஒவ்வொரு scan runner-ம் ENGINE_SCAN_RUNNER_MEMORY_RESERVATION_MB=1536 என்ற soft reservation-ஐயும், ENGINE_SCAN_RUNNER_MEMORY_MB=1536 என்ற hard cap-ஐயும் கொண்டிருக்கும். எனவே, இரண்டு workers இயங்குவதற்கு முன்பே சுமார் 5 GB நினைவகம் தேவைப்படும். மீதமுள்ள நினைவகத்திற்குள் அடங்கும் runner-களை மட்டுமே engine அனுமதிக்கும். இதனால், சிறிய கணினிகளில் ஸ்கேன் தோல்வியடைவதற்குப் பதிலாக வரிசையில் (queue) காத்திருக்கும்; இது out-of-memory killer-ஆல் செயல்முறை நிறுத்தப்படுவதை விடச் சிறந்ததாகும். ஒவ்வொரு பணிக்கும் தனித்தனி container-ஐப் பயன்படுத்தும் அனைத்து கருவிகளுக்கும் இதே கணக்கீடு பொருந்தும். இதனால்தான் OpenBot-ன் ஒவ்வொரு AI coworker-க்கும் ஒரு container மற்றும் browser என்பது CPU வரம்பை எட்டுவதற்கு முன்பே RAM வரம்பை எட்டிவிடுகிறது.

இரண்டு prune அமைப்புகள் இயல்பாகவே true என இருக்கும்: ENGINE_AUTO_PRUNE_DOCKER_BUILD_CACHE மற்றும் ENGINE_AUTO_PRUNE_UNUSED_DOCKER_IMAGES. ஒரு பணி முடிந்ததும், பயன்படுத்தப்படாத build cache, images மற்றும் நிறுத்தப்பட்ட scan containers-ஐ engine நீக்கிவிடும். ஏதேனும் container-ஆல் குறிக்கப்படும் images, service containers, bind mounts, database தரவுகள், credentials மற்றும் volumes ஆகியவை பாதுகாக்கப்படும். நீங்கள் கட்டமைக்காத ஒரு pruner, உங்கள் Docker daemon-ல் இயங்கிக்கொண்டிருக்கும் என்பதால், இந்த host-ஐ மற்ற சேவைகளுடன் பகிராமல் இருப்பது நல்லது.

பெரும்பாலான பயனர்கள் மாற்றும் engine அமைப்புகள்
  • ENGINE_WORKER_COUNT: scan steps மற்றும் post-processing-ஆல் பகிரப்படும் மொத்த worker slots. புதிய பணிகளை நிறுத்தி வைக்க இதை 0 என அமைக்கவும்.
  • ENGINE_MAX_CONCURRENT_SCANS: ஒரே நேரத்தில் அனுமதிக்கப்படும் ஸ்கேன்களின் எண்ணிக்கை. வரிசையில் உள்ள ஸ்கேன்கள், active pool காலியாகும் வரை காத்திருக்கும்.
  • ENGINE_MAX_WORKERS_PER_SCAN: 0 என அமைத்தால், மொத்த slots-ம் ஸ்கேன்களுக்கு இடையே சமமாகப் பகிரப்படும்.
  • ENGINE_HARNESS_TIMEOUT_SECONDS: இயல்பாக 7200. ஒரு பணி அதிகபட்சமாக இயங்கக்கூடிய கால அளவு. engine 60 முதல் 86400 வரையிலான மதிப்புகளை ஏற்கும். இந்த வரம்பிற்கு வெளியே உள்ள மதிப்புகள் (0 உட்பட) 7200 என மாற்றப்படும்.
  • ENGINE_MIN_FREE_STORAGE_GB: சேமிப்பகத்தின் குறைந்தபட்ச அளவு. ENGINE_IGNORE_LOW_STORAGE=true இந்த பாதுகாப்பை முடக்கும். இதைச் செய்தால் host disk நிரம்பிவிடும் அபாயம் உள்ளதாகக் கோப்பு எச்சரிக்கிறது.
  • ENGINE_SCAN_RUNNER_MEMORY_MB: ஒவ்வொரு runner-க்கான hard memory cap. 0 என அமைத்தால் வரம்பு நீக்கப்படும்.
  • ENGINE_SCAN_RUNNER_MEMORY_RESERVATION_MB: admission கணக்கீட்டிற்கான ஒவ்வொரு runner-ன் soft reservation. இதைக்குறைப்பதன் மூலம் idle memory-ஐ அதிகமாகப் பயன்படுத்தலாம், அதே சமயம் hard cap நினைவகத்தின் திடீர் அதிகரிப்பைக் கட்டுப்படுத்தும்.

உள்ளூர் repository-ஐ கசியவிடாமல் ஸ்கேன் செய்தல்

LOCAL_REPOS_PATH இயல்பாக ./local_repos என்று அமையும். இது backend மற்றும் engine containers-க்குள் read-only முறையில் bind-mount செய்யப்படுகிறது. எனவே, host-ல் உள்ள அந்த folder-ல் நீங்கள் போடும் repository, உடனடியாக containers-க்குள் தெரியும். உங்கள் working tree-ஐப் பயன்படுத்தாமல், புதிய clone-ஐப் பயன்படுத்தவும். Job container-க்கு ஒரு writable copy கிடைக்கிறது; அதற்குள் அது root ஆகச் செயல்படும் மற்றும் இணைய அணுகலும் இருக்கும். இதனால் அந்த copy-ல் உள்ள எதையும் மாற்றவோ அல்லது வெளியே அனுப்பவோ முடியும். ஒரு project-ஐ நகலெடுக்கும் முன் .env கோப்புகள் மற்றும் private keys-ஐ நீக்கிவிடவும்.

உங்களுக்குக் கிடைப்பவை மற்றும் கிடைக்காதவை

தரவரிசைப்படுத்தப்பட்ட candidate findings உங்களுக்குக் கிடைக்கும். சரிபார்க்கப்பட்ட vulnerabilities உங்களுக்குக் கிடைக்காது. தரவரிசைப்படுத்துதல் மற்றும் de-duplication ஆகியவை உங்கள் triage queue-ன் வரிசையைத் தீர்மானிக்கின்றன. அவை ஒரு entry உண்மையானது என்பதை நிரூபிப்பதில்லை. Post-scripts சரிபார்ப்பை முயற்சி செய்து ஒரு proof of concept-ஐ உருவாக்கலாம், இதுவே இந்த tool வழங்கும் வலுவான சமிக்ஞையாகும்; ஆனால், ஒரு post-script தோல்வியடைவது அந்த finding தவறானது என்பதற்கான ஆதாரம் அல்ல. ஒவ்வொரு candidate-ஐயும் ஒரு நபர் இன்னும் படிக்க வேண்டியுள்ளது. ஒரு candidate-க்கும் ஒரு ஆதாரத்திற்கும் இடையே உள்ள அந்த இடைவெளிதான், நீங்களே மீண்டும் இயக்கக்கூடிய ஆதாரத்தை ஒரு agent-இடம் கேட்பது ஏன் இங்கே பயனுள்ளதாக இருக்கிறது என்பதற்கான காரணம்: நீங்கள் நம்பிக்கையுடன் ஏற்றுக்கொள்ள வேண்டிய தரவரிசைப்படுத்தப்பட்ட finding-ஐ விட, தேவைப்படும்போது நீங்களே reproduce செய்யக்கூடிய finding அதிக மதிப்புடையது.

open-kritt எத்தனை உண்மையான bugs-ஐக் கண்டறியும் என்பது குறித்து இந்த வழிகாட்டி எந்தக் கூற்றையும் முன்வைக்கவில்லை, ஏனெனில் நாங்கள் அதை அளவிடவில்லை. உங்கள் codebase-க்கு ஒரு detection rate-ஐக் குறிப்பிடும் எவரும் அதை உங்கள் codebase-ல் இயக்கிப் பார்த்திருக்க மாட்டார்கள். உங்களுக்கு ஏற்கனவே நன்கு தெரிந்த ஒரு repository-ஐ முதலில் scan செய்யுங்கள்: நீங்களே மதிப்பிடக்கூடிய findings-தான் மிகக் குறைந்த செலவில் கிடைக்கும் calibration ஆகும்.

பெரும்பாலான self-hosted tools-ஐ விட இங்கே Authorization முக்கியமானது. Agents குறியீட்டைத் தொகுத்து இயக்குவதோடு network-ஐயும் அணுகுகின்றன, எனவே ஒரு proof-of-concept படிநிலை நேரடி (live) systems-ஐத் தொடக்கூடும். உங்களுக்குச் சொந்தமான அல்லது நீங்கள் சோதனை செய்ய ஒப்பந்தம் செய்யப்பட்ட குறியீட்டில் இதைச் சுட்டிக்காட்டுங்கள், மேலும் எதையும் இயக்கும் முன் target scope-ஐக் குறித்துக்கொள்ளுங்கள். நீங்கள் ANTHROPIC_API_KEY-ஐ configure செய்து Claude Code engine-ஐப் பயன்படுத்தினால், Claude Code-ஐ VPS-ல் பாதுகாப்பாக இயக்குதல் என்பதில் உள்ள sandboxing பழக்கவழக்கங்கள் இந்த agents-க்கும் பொருந்தும்.

FAQ

open-kritt-க்கு ஏன் தனி VPS தேவை?

இதன் analysis agents, உங்கள் code-ன் நகல்களைக் கொண்டு, root அனுமதியுடன் disposable job containers-ல் இயங்குகின்றன. மேலும், engine service-ஆனது host Docker socket-ஐ mount செய்வதால், ஒவ்வொரு job-க்கும் ஒரு container-ஐ உருவாக்க முடியும். அந்த socket-ஐ அணுகும் எந்தவொரு process-ம் host filesystem-ஐ mount செய்யும் container-ஐ உருவாக்க முடியும் என்பதால், இந்த stack முழுவதையும் host-ன் root-ஆகவே கருத வேண்டும். ஒரு dedicated VPS-ல் இது ஏற்றுக்கொள்ளக்கூடிய ஒரு சமரசம், மேலும் அந்த server-ஐ மீண்டும் உருவாக்குவது எளிது. உங்கள் அன்றாட workstation-ல் இதை இயக்கினால், உங்கள் SSH keys மற்றும் browser profiles ஆகியவை நீங்கள் scan செய்யும் code-ன் அதே trust boundary-க்குள் வந்துவிடும்.

SSH tunnel-க்கு பதிலாக port 5173-ஐ நேரடியாகத் திறக்கலாமா?

அவ்வாறு செய்யக்கூடாது. இந்த backend-ல் application authentication வசதி இல்லை. எனவே, இணையத்திற்கும் உங்கள் findings மற்றும் provider credit-க்கும் இடையே அந்த port மட்டுமே பாதுகாப்பாக உள்ளது. இதனால்தான் compose file-ல் அனைத்து service-களும் 127.0.0.1-ல் bind செய்யப்பட்டுள்ளன. அதற்குப் பதிலாக ssh -N -L 5173:127.0.0.1:5173 you@your-server-ip-ஐ இயக்கி, உள்ளூர் அளவில் http://localhost:5173-க்குச் செல்லவும். ufw rule-ஐ நம்பி இருக்க வேண்டாம், ஏனெனில் Docker port-கள் ufw-ன் default policy-க்கு முன்பே கையாளப்படுகின்றன.

open-kritt-ன் செலவை நான் எவ்வாறு கட்டுப்படுத்துவது?

முதல் scan-க்கு முன்பே உங்கள் model provider-ன் console-ல் ஒரு hard limit-ஐ அமைக்கவும், ஏனெனில் open-kritt-ல் சொந்தமாக budget setting கிடையாது. முதல் சில முறை இயக்கும்போது, ENGINE_WORKER_COUNT=2 மற்றும் ENGINE_MAX_CONCURRENT_SCANS=1 ஆகியவற்றுக்கான default concurrency அளவுகளை மாற்ற வேண்டாம். ஒரு provider account-ல் default-ஆக 15 concurrent root model calls வரை அனுமதிக்கப்படும் என்பதையும், ஒரு Codex session-ல் ஐந்து child agents வரை இயங்கக்கூடும் என்பதையும் நினைவில் கொள்ளவும். ENGINE_WORKER_COUNT=0 புதிய job-களை எடுப்பதை நிறுத்திவிடும், இதுவே மிக வேகமான உள்ளூர் தடுப்பு முறையாகும்.

நான் எந்த version-ஐப் பயன்படுத்த வேண்டும்?

எப்போதும் ஒரு tag-ஐப் பயன்படுத்தவும், main-ஐ ஒருபோதும் பயன்படுத்த வேண்டாம். git fetch --tags-ஐத் தொடர்ந்து git tag --list-ஐ இயக்கினால் என்னென்ன versions உள்ளன என்று தெரியும். 16 August 2026 அன்று வெளியிடப்பட்ட v1.4.1, 12 October 2026 நிலவரப்படி புதியது. ஒரு version-ஐ pin செய்வதன் மூலம், மாதங்கள் கழித்து மீண்டும் build செய்தாலும் அதே stack கிடைக்கும். மேலும், release notes-ஐப் படித்த பிறகு upgrade செய்வது உங்கள் முடிவாக இருக்கும், மாறாக வேறு ஒரு நாளில் clone செய்யும்போது தற்செயலாக நடக்கும் மாற்றமாக இருக்காது.

scan தொடங்கவில்லை என்றால், எதைச் சரிபார்க்க வேண்டும்?

முதலில் disk space-ஐச் சரிபார்க்கவும். free storage ENGINE_MIN_FREE_STORAGE_GB-க்குக் குறைவாக இருந்தால் (default 20 GB), engine-ஆல் scan container-ஐத் தொடங்க முடியாது. பிறகு ENGINE_WORKER_COUNT-ன் மதிப்பு 0 இல்லை என்பதை உறுதிப்படுத்தவும், ஏனெனில் அந்த மதிப்பு புதிய job-களை எடுப்பதைத் தடுத்துவிடும். அடுத்து, ./kritt setup-ஐ இயக்கி model credential சரியாக உள்ளமைக்கப்பட்டுள்ளதா எனப் பார்க்கவும், ஏனெனில் வெறும் GITHUB_TOKEN மட்டும் scan-ஐ இயக்க முடியாது. docker compose logs engine அந்த job ஏன் தவிர்க்கப்பட்டது என்பதற்கான காரணத்தைக் காட்டும்.

இந்தக் கட்டுரை பயனுள்ளதாக இருந்ததா?