VPSలో OpenHandsను Dockerతో సురక్షితంగా నడపడం ఎలా

OpenHands అంటే ఏమిటి, ముందుగా అర్థం చేసుకోవాల్సిన ఒక ప్రమాదం

OpenHands, గతంలో OpenDevin, ఒక స్వయంప్రతిపత్తి కలిగిన software-engineering agent. మీరు దీనికి సాధారణ భాషలో ఒక task ఇస్తే, ఇది పనిని ప్రణాళిక చేస్తుంది, code రాస్తుంది, commands నడుపుతుంది, output చదువుతుంది, task పూర్తయ్యే వరకు ప్రక్రియను పునరావృతం చేస్తుంది. మీరు దీన్ని Dockerతో మీ స్వంత serverపై నడిపి, ఒక language modelకు అనుసంధానిస్తారు. VPSపై నడిపినప్పుడు, మీరు అందుబాటులో లేని సమయంలో కూడా పనిచేసే coding agentగా ఇది మారుతుంది.

మీ మొత్తం setupను ఒక విషయం నిర్దేశించాలి. OpenHands కేవలం codeను సూచించదు; అది codeను అమలు కూడా చేస్తుంది. అందుకోసం దాని controller container host Docker socketను /var/run/docker.sock వద్ద mount చేస్తుంది, తద్వారా ప్రతి task కోసం sandbox containersను ప్రారంభించగలదు. Docker socketతో communicate చేయగల ఏదైనా మొత్తం host filesystemను mount చేసిన కొత్త containerను ప్రారంభించగలదు. అంటే socket access వాస్తవంగా ఆ machineపై root accessతో సమానం. కాబట్టి OpenHands boxను untrusted codeను నడిపే serverగా పరిగణించండి, ఎందుకంటే అది నిజంగా అదే చేస్తుంది. దిగువన ఉన్న ప్రతి hardening నిర్ణయం ఈ విషయంపై ఆధారపడి ఉంటుంది.

అవసరమైనవి

మీకు ఇటీవలి Docker Engine తో Ubuntu 24.04 నడుస్తున్న VPS, కనీసం 4 GB RAM, అలాగే ఒక language model కోసం API key (OpenAI, Anthropic లేదా Google) అవసరం. ప్రత్యామ్నాయంగా, అదే VPSలో Ollama ద్వారా అందించే local model ను ఉపయోగించవచ్చు. OpenHands డజన్ల కొద్దీ model backends కు మద్దతు ఇస్తుంది. కాబట్టి ఎంపిక మీది. మీరు ఇంతకు ముందు containers ను setup చేయకపోతే, VPSలో Docker ప్రాథమికాలు ఈ guide అనుసరించే అవసరమైన పునాదిని వివరిస్తాయి.

Dockerతో ఇన్‌స్టాల్ చేయండి

OpenHands రెండు images గా విడుదలవుతుంది: మీరు నడిపే application image, అలాగే ప్రతి task యొక్క sandbox ను నడపడానికి అది pull చేసే agent-server image. Project docs లో ఉన్న ప్రస్తుత tags ను ఉపయోగిస్తూ, కింది విధంగా అమలు చేయండి:

docker run -it --rm --pull=always \
  -e AGENT_SERVER_IMAGE_REPOSITORY=ghcr.io/openhands/agent-server \
  -e AGENT_SERVER_IMAGE_TAG=1.26.0-python \
  -e LOG_ALL_EVENTS=true \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v ~/.openhands:/.openhands \
  -p 127.0.0.1:3000:3000 \
  --add-host host.docker.internal:host-gateway \
  --name openhands \
  docker.openhands.dev/openhands/openhands:1.8

ఒక గంట గందరగోళాన్ని నివారించే రెండు ముఖ్యమైన విషయాలు ఉన్నాయి. app image మరియు agent-server image లకు ఉద్దేశపూర్వకంగా వేర్వేరు version numbers ఉంటాయి. అందువల్ల వాటిని ఒకేలా చేయడానికి ప్రయత్నించవద్దు. మీ app version తో docs లో జతచేసిన agent-server tag ను ఉపయోగించండి. అలాగే -p 3000:3000 కు బదులుగా -p 127.0.0.1:3000:3000 ఉన్న విషయాన్ని గమనించండి. ఈ ఒక్క మార్పు వల్ల మీరు మాత్రమే చేరుకోగల Web UI కి, మొత్తం internet చేరుకోగల Web UI కి మధ్య తేడా ఏర్పడుతుంది. తదుపరి section ఇదే విషయాన్ని వివరిస్తుంది.

Web UIని public internet నుండి దూరంగా ఉంచండి

OpenHands తన interface ను port 3000 పై అందిస్తుంది. ఆ interface code ను అమలు చేసే agent ను నడుపుతుంది. అందువల్ల దాన్ని internet కు public చేస్తే, దాన్ని కనుగొన్న ఎవరైనా commands అమలు చేసే process లోకి remote మార్గాన్ని పొందగలరు. పై run command చేసినట్లే దాన్ని loopback కు bind చేయండి. తరువాత SSH tunnel ద్వారా మీ laptop నుంచి దాన్ని access చేయండి:

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

తర్వాత మీ స్వంత machine లో http://127.0.0.1:3000 ను తెరవండి. ఈ traffic మీకు ఇప్పటికే ఉన్న SSH session ద్వారా వెళుతుంది. public internet పై కొత్తగా ఏదీ listen చేయదు. ప్రతి agent కు port అవసరం ఉండదు. అదే VPS పై నడిచే Claude Code sessions terminal ద్వారా పరస్పరం సందేశాలు పంపుకుంటాయి. అందువల్ల మీరు ఎప్పుడూ expose చేసేది SSH మాత్రమే. మీరు host చేసే ప్రతి agent dashboard కు ఇదే loopback-and-tunnel పద్ధతిని ఉపయోగించడం మంచిది. open-kritt యొక్క scanning UIను tunnel ద్వారా access చేయడం కూడా ఇదే విధంగా పనిచేస్తుంది; అయితే అది port 5173 పై ఉంటుంది. మరింత శాశ్వత setup కోసం దాన్ని VPN వెనుక ఉంచండి. ఏ పద్ధతి ఎంచుకున్నా, server ముందు default-deny firewall ఉంచండి. దాంతో ఏదీ అనుకోకుండా expose కాదు. IPv4ను మాత్రమే కవర్ చేసే firewall అదే portను IPv6పై తెరిచి ఉంచుతుందని గుర్తుంచుకోండి. ఇదే చాలా మందికి సమస్య కలిగించే IPv6 firewall gap.

model key మరియు repo credentials‌ను వేరు చేసి భద్రపరచండి

OpenHands తన model కోసం API key‌ను, అలాగే మీ repositories‌ను clone మరియు push చేయడానికి తరచుగా token‌ను అవసరం చేస్తుంది. ఈ రెండింటితో ఖర్చులు జరగవచ్చు మరియు అవి మీ తరఫున చర్యలు తీసుకోగలవు. అందువల్ల వాటిని passwords‌లా పరిగణించండి. వాటిని సరైన account మాత్రమే చదవగలిగే environment file‌లో ఉంచండి. వాటిని run command‌లో ఎప్పుడూ ఉంచవద్దు. అలా ఉంచితే అవి shell history మరియు process list‌లో కనిపిస్తాయి. git repository లోపల ఉన్న file‌లో కూడా వాటిని ఎప్పుడూ ఉంచవద్దు. అసలు credentials‌ను self-hosted password manager‌లో ఉంచితే, ఆ server‌ను కూడా కఠినంగా భద్రపరచండి. ఎందుకంటే vault‌లోని బలహీనమైన భాగాలు సాధారణంగా encrypted items కాకుండా admin token మరియు backup file ఉంటాయి. Vaultwarden hardening pass లో ఇదే అంశాలను పరిశీలిస్తుంది.

మీరు వదిలివేయగల సర్వర్‌పై దీన్ని నడపండి

Controller వద్ద Docker socket ఉండాల్సి ఉన్నందున, OpenHands ను దాని host నుంచి పూర్తిగా sandbox చేయలేరు. దీనికి నిజాయితీగల mitigation placement ద్వారా isolation కల్పించడం: మీ database లేదా website ను కూడా నడిపే సర్వర్‌పై కాకుండా, మీకు ముఖ్యమైన మరే ఇతరదీ లేని ప్రత్యేక VPS పై OpenHands ను నడపండి. ప్రారంభించే ముందు snapshot తీసుకోండి. ఒక వారం పాటు agent-authored code నడిపిన సర్వర్‌పై ఆధారపడకుండా, ఆ snapshot నుంచి rebuild చేయండి. చవకైన, వదిలివేయగల, ఒకే-purpose VPS దీనికి సరైన స్థానం. ఇక్కడ OpenHands నిజంగా అందించే నియంత్రణ placement మాత్రమే. కాబట్టి agent ఆగి మిమ్మల్ని అడిగే ముందు ఎంతవరకు పని చేయవచ్చో కూడా నియంత్రించాలనుకుంటే, Claude Code యొక్క permission modes ద్వారా ఎవరూ పర్యవేక్షించని సర్వర్‌లో ఆ రెండో నియంత్రణ ఎలా ఉంటుందో చూడవచ్చు.

దాని చుట్టూ సర్వర్‌ను బలోపేతం చేయండి

మిగతాది సాధారణ server hygiene. అయితే workload సాధారణం కంటే ఎక్కువ ప్రమాదకరమైనది కాబట్టి, ఇక్కడ ఇవి మరింత ముఖ్యమైనవి. root గా పని చేయకుండా, unprivileged admin user ను సృష్టించండి. ఇందుకోసం unprivileged user గా సేవలను నడపడం చూడండి. SSH ను key-only authentication కు మార్చండి. తరువాత దిగువ checklist ను అమలు చేసి, మళ్లీ కనిపించే ప్రదేశంలో భద్రపరచండి.

వాటిని కేవలం అమలు చేయడం కాకుండా, వాటి వెనుక ఉన్న భాగాలను అర్థం చేసుకోవడానికి VPS పై మీ స్వంత AI agent ను నిర్మించడం చూడండి. తక్కువ code అవసరమైన platform కోసం Dify ను self-host చేయడం సులభమైన ప్రారంభ మార్గం.

FAQ

OpenHands ను సర్వర్‌పై నడపడం సురక్షితమేనా?

జాగ్రత్తగా నిర్వహిస్తే సురక్షితంగా ఉండవచ్చు. అయితే ఇది సాధారణ web app కంటే ఎక్కువ ప్రమాదకరం. OpenHands code ను రాసి అమలు చేస్తుంది. దీని controller host Docker socket ను కలిగి ఉంటుంది. ఈ socket కు machine పై root స్థాయి నియంత్రణ ఉంటుంది. అందువల్ల OpenHands ను ఇతర విలువైన డేటా లేని, ప్రత్యేకంగా కేటాయించిన, అవసరమైతే తొలగించి మళ్లీ నిర్మించగల VPS పై నడపండి. దీని Web UI ను loopback పై మాత్రమే ఉంచి, SSH tunnel లేదా VPN వెనుక అందుబాటులోకి తీసుకురండి. దాని keys ను వేరుగా ఉంచండి. ఆ సర్వర్‌ను harden చేయండి. మీ ముఖ్యమైన services పక్కన OpenHands ను నడపవద్దు.

OpenHands కు Docker socket ఎందుకు అవసరం?

OpenHands ప్రతి task ను కొత్త sandbox container లో నడుపుతుంది. ఆ containers ను సృష్టించడానికి host Docker daemon ను ఇది ఉపయోగిస్తుంది. అందుకోసం /var/run/docker.sock ను controller లో mount చేస్తుంది. దీని వల్ల controller container కు host లోని Docker పై నియంత్రణ లభిస్తుంది. ఇది శక్తివంతమైనదే కాకుండా ప్రమాదకరం కూడా. కాబట్టి host స్వయంగా untrusted code ను నడిపే సిస్టమ్‌గా పరిగణించాలి.

Paid API బదులుగా OpenHands ఒక local model ను ఉపయోగించగలదా?

అవును. Ollama లేదా vLLM ద్వారా అందించే local models కు OpenHands మద్దతు ఇస్తుంది. అందువల్ల ప్రతి token కు ఖర్చు లేకుండా, మీ server వెలుపల data పంపకుండా పూర్తిగా self-hosted విధంగా దీన్ని నడపవచ్చు. సామర్థ్యం ఉన్న coding model ను నడపడానికి తగినంత memory కలిగిన machine అవసరం. ఇది Ollama guide లో వివరించిన sizing ప్రశ్నతో సమానం.

OpenHands ను నా ప్రధాన server పై నడపాలా?

వద్దు. OpenHands agent-authored code ను నడుపుతుంది మరియు Docker socket ను కలిగి ఉంటుంది. కాబట్టి మీరు అవసరమైతే మళ్లీ నిర్మించడానికి సిద్ధంగా ఉన్న ప్రత్యేక, ఒకే పనికి కేటాయించిన VPS పై దీన్ని ఉంచండి. Database, website లేదా ఇతర services తో దీన్ని ఒకే server లో ఉంచితే, agent చేసిన పొరపాటు లేదా దానిలోని bug అది తాకకూడని వనరులను కూడా ప్రభావితం చేయవచ్చు.