సర్వర్‌లో Claude Code ను సురక్షితంగా రన్ చేయడం ఎలా?

సర్వర్‌లో Claude Code ను సురక్షితంగా రన్ చేయడం అంటే ఏమిటి

సర్వర్‌లో Claude Code ను సురక్షితంగా రన్ చేయడానికి, దాని permission prompts ను ఆన్ లో ఉంచండి. దీనిని ప్రత్యేకమైన unprivileged user గా రన్ చేయండి. unattended runs (పర్యవేక్షణ లేని రన్‌లు) కోసం నమ్మకంపై ఆధారపడకుండా, ఒక వాస్తవమైన సరిహద్దును ఏర్పాటు చేయండి: అంటే built-in sandbox, ఒక container, లేదా మీకు ఏమాత్రం ప్రాముఖ్యత లేని disposable VPS ను వాడండి. --dangerously-skip-permissions flag, మోడల్‌కు మరియు మీ shell కు మధ్య ఉండే approval దశను తొలగిస్తుంది. పర్యవేక్షణ లేని పనుల కోసం ఈ మార్పు ఆమోదయోగ్యమే కావచ్చు, కానీ ఒక తప్పుడు command దేనిని తాకగలదో పరిమితం చేసే సరిహద్దు లోపల మాత్రమే దీనిని చేయాలి. ఈ flag వాస్తవానికి దేనిని మారుస్తుందో మరియు పెరుగుతున్న isolation స్థాయిలతో ఆ సరిహద్దును ఎలా నిర్మించాలో ఈ గైడ్ వివరిస్తుంది.

మీ సర్వర్‌లో Claude Code ఏమి చేయగలదు

Claude Code అనేది మీ టెర్మినల్‌లో నడిచే ఒక కోడింగ్ ఏజెంట్. ఇది ఫైళ్లను చదవగలదు, రాయగలదు మరియు దానిని ప్రారంభించిన వినియోగదారునిగా షెల్ కమాండ్లను అమలు చేయగలదు. ఈ సాధనం యొక్క ప్రధాన ఉద్దేశ్యం ఇదే: ఇది ఒక రిపోజిటరీని క్లోన్ చేయడం, కోడ్‌ను ఎడిట్ చేయడం, టెస్టులను రన్ చేయడం, ఫెయిల్యూర్లను చదవడం మరియు కోడ్‌ను సరిచేయడం వంటి పనులను మీరు ప్రతి కమాండ్‌ను టైప్ చేయాల్సిన అవసరం లేకుండానే లూప్‌లో చేయగలదు. మీరు దీనిని ఇంకా సర్వర్‌లో సెటప్ చేయకపోతే, running Claude Code on a VPS with tmux లో ఇన్‌స్టాలేషన్ మరియు సెషన్ నిర్వహణ గురించి చూడవచ్చు. ఈ పేజీలో అది అందుబాటులోకి వచ్చిన తర్వాత దానికి ఉండే సామర్థ్యాల గురించి వివరించబడింది.

దీని వల్ల కలిగే ప్రమాదం ఏమిటంటే, ఒక ప్రాసెస్ మీ వినియోగదారునిగా షెల్ కమాండ్లను రన్ చేస్తున్నప్పుడు, మీ వినియోగదారునికి ఉన్న అన్ని అనుమతులు దానికి ఉంటాయి. ఇది ~/.ssh/id_ed25519, ~/.aws/credentials మరియు మీ వినియోగదారుడు తెరవగలిగే ప్రతి .env ఫైల్‌ను చదవగలదు. ఇది curl ను రన్ చేయగలదు మరియు సర్వర్ చేరుకోగల ఏ హోస్ట్‌కైనా డేటాను పంపగలదు. ఇది git push --force ను రన్ చేయగలదు. ఈ ఏజెంట్‌కు సొంతంగా ఎటువంటి ఉద్దేశాలు ఉండవు. ప్రమాదం ఎక్కడ వస్తుందంటే, ఒక పని తప్పుగా జరిగినప్పుడు లేదా అది పని చేస్తున్నప్పుడు చదివిన టెక్స్ట్‌లో వేరొకరు రాసిన సూచనలు ఉన్నప్పుడు: అది ఫెచ్ చేసిన వెబ్ పేజీ లేదా అది సరిచేయాల్సిన ఇష్యూలోని కామెంట్ కావచ్చు. ఈ రెండో సందర్భాన్ని ప్రాంప్ట్ ఇంజెక్షన్ (prompt injection) అంటారు, అందుకే "మోడల్ సాధారణంగా తెలివిగానే ఉంటుంది" అనేది భద్రతా ప్రణాళిక కాదు. సూచనలు మరింత దగ్గర నుండి కూడా రావచ్చు, ఎందుకంటే two Claude Code sessions on the same box can send text to each other, మరియు ఒక సిబ్లింగ్ సెషన్ నుండి వచ్చే సందేశం కూడా రిసీవింగ్ ఏజెంట్ చదివే మరొక టెక్స్ట్ మాత్రమే. మీరు సగటు పనితీరు కోసం కాకుండా, తప్పుగా జరిగే సందర్భం కోసం ప్రణాళిక సిద్ధం చేసుకోవాలి.

అనుమతుల వ్యవస్థ గురించి సరళంగా

సాధారణంగా, Claude Code ఏదైనా చర్య తీసుకునే ముందు మిమ్మల్ని అడుగుతుంది. ప్రాజెక్ట్‌లోని ఫైళ్లను చదవడం నిశ్శబ్దంగా జరుగుతుంది, కానీ ఒక ఫైల్‌ను ఎడిట్ చేయడం లేదా shell కమాండ్‌ను రన్ చేయడం వంటివి చేసేటప్పుడు, అది ముందుగా మీకు ఆ మార్పును లేదా కమాండ్‌ను చూపిస్తుంది మరియు మీ అనుమతి కోసం వేచి ఉంటుంది. మీరు ఒక చర్యను ఆమోదించవచ్చు లేదా ఆ సెషన్ మొత్తం అటువంటి చర్యలను ఆమోదించవచ్చు. ఈ అనుమతులు ఆ సెషన్‌కు మాత్రమే పరిమితం: మీరు CLI నుండి బయటకు రాగానే, తదుపరి సెషన్ మళ్ళీ జాగ్రత్తగా (cautious) ప్రారంభమవుతుంది. మీరు శాశ్వతంగా ఉంచుకోవాలనుకునే నియమాల కోసం, settings ఫైల్‌లో persistent allow, ask, మరియు deny జాబితాలు ఉంటాయి. ఉదాహరణకు: git status ను అనుమతించడం, git push పై అడగడం, .env ను చదవకుండా నిరాకరించడం. నిరాకరణ (deny) నియమాలు ఎల్లప్పుడూ ప్రాధాన్యత కలిగి ఉంటాయి. ఈ ప్రాథమిక స్థితి మారుతోంది, ఎందుకంటే 14 August 2026 నుండి auto mode డిఫాల్ట్‌గా మారుతుంది. కాబట్టి, మీరు పర్యవేక్షించలేని సర్వర్‌లో ఏ మోడ్ రన్ చేయాలో నిర్ణయించుకునే ముందు ప్రతి అనుమతి మోడ్ వాస్తవానికి దేనిని అనుమతిస్తుందో తెలుసుకోవడం మంచిది.

ఈ డిజైన్ ఒక మనిషి టెర్మినల్‌ను చూస్తున్నాడని భావిస్తుంది, ల్యాప్‌టాప్‌లో ఇది నిజమే. సర్వర్‌పై, ఎవరూ చూడకపోవడమే ప్రధాన ఉద్దేశ్యం. మీరు tmux లో ఒక సుదీర్ఘమైన పనిని ప్రారంభించి నిద్రపోతారు, అప్పుడు ఉదయం 2 గంటలకు ప్రశ్న అడగడానికి ఆగిపోయే ఏజెంట్ ఉదయం వరకు ఎటువంటి పురోగతి సాధించదు. ఈ విరామం సమయంతో పాటు డబ్బును కూడా వృథా చేస్తుంది, ఎందుకంటే నిష్క్రియంగా ఉన్న Claude Code సెషన్ దాని warm prompt cache ను కోల్పోతుంది మరియు తదుపరి టర్న్ కోసం దాన్ని మళ్ళీ నిర్మించడానికి ఖర్చు అవుతుంది. సర్వర్లలో ప్రజలు skip ఫ్లాగ్‌ను ఎంచుకోవడానికి ఇదే అసలైన కారణం, మరియు అది పరిష్కరించే సమస్య నిజమైనది. ఈ గైడ్‌లోని మిగిలిన భాగం, ప్రతి రక్షణ కవచాన్ని (guardrail) వదులుకోకుండా దీన్ని ఎలా పరిష్కరించాలో వివరిస్తుంది.

--dangerously-skip-permissions ఏమి మారుస్తుంది

claude --dangerously-skip-permissions ఇది ఆమోదం తెలిపే దశను నిలిపివేస్తుంది. ఎటువంటి ప్రాంప్ట్ లేకుండానే మార్పులు జరుగుతాయి. షెల్ కమాండ్లు ప్రాంప్ట్ అడగకుండానే రన్ అవుతాయి. సాధారణంగా సున్నితమైన స్థానాలను రక్షించే protected-path తనిఖీలను కూడా ఇది దాటవేస్తుంది. మీరు స్పష్టంగా విధించిన deny నియమాలు ఇప్పటికీ వర్తిస్తాయి, మరియు కొన్ని అత్యంత ప్రమాదకరమైన చర్యలు ఇంకా ఆగి అడుగుతాయి, కానీ దీని సారాంశం సరళమైనది: మోడల్ ఏది రన్ చేయాలని నిర్ణయిస్తే, అది రన్ అవుతుంది.

సర్వర్‌పై ఈ ఫ్లాగ్‌కు సంబంధించి రెండు విషయాలు ముఖ్యమైనవి. మొదటిది, Linux మరియు macOS లలో Claude Code ను root గా లేదా sudo కింద రన్ చేసినప్పుడు ఇది బ్లాక్ చేయబడుతుంది, ఎందుకంటే ప్రాంప్ట్‌లు లేని root యూజర్ మెషీన్‌లోని ఏ ఫైల్‌నైనా లేదా సర్వీస్‌నైనా మార్చగలడు. ఏజెంట్‌కు ఎలాగూ దాని స్వంత unprivileged అకౌంట్ అవసరం, మరియు ఈ ఫ్లాగ్ దానిని అమలు చేస్తుంది. రెండవది, ఈ ఫ్లాగ్ మోడల్ ప్రవర్తనను ఏ విధంగానూ మార్చదు. ఇది మనిషిని లూప్ నుండి తొలగిస్తుంది తప్ప మరేమీ మార్చదు, కాబట్టి ప్రాంప్ట్ ద్వారా పట్టుబడాల్సిన ప్రతి తప్పు ఇప్పుడు నేరుగా అమలు అవుతుంది.

కాబట్టి ఇక్కడ వాస్తవిక లెక్క ఇది. మీరు పర్మిషన్లను దాటవేస్తే, భద్రతా ప్రశ్న "ఏజెంట్ ఏదైనా చెడు పని చేస్తుందా" నుండి "ఒక తప్పుడు చర్య ఎంత నష్టాన్ని కలిగించగలదు" అనే దానికి మారుతుంది. మీరు ప్రతి నిర్ణయాన్ని నియంత్రించడానికి ప్రయత్నించడం ఆపి, నష్టం జరిగే పరిధిని (blast radius) నియంత్రించడం ప్రారంభిస్తారు. దీనికి సమాధానం Containment, మరియు ఇది వివిధ స్థాయిలలో ఉంటుంది.

అంతర్నిర్మిత Claude Code శాండ్‌బాక్స్

ఈ దశలకు ముందు, Claude Code ఇప్పుడు తాను రన్ చేసే కమాండ్ల కోసం OS-స్థాయి శాండ్‌బాక్స్‌ను కలిగి ఉందని గమనించండి. ఇది చాలా సందర్భాల్లో skip ఫ్లాగ్‌ను ఉపయోగించాల్సిన అవసరాన్ని తొలగిస్తుంది. Linuxలో ఇది ఫైల్‌సిస్టమ్ ఐసోలేషన్ కోసం bubblewrapను, నెట్‌వర్క్ ట్రాఫిక్‌ను ప్రాక్సీ ద్వారా పంపడానికి socatను ఉపయోగిస్తుంది. శాండ్‌బాక్స్ లోపల, ఒక కమాండ్ కేవలం ప్రాజెక్ట్ డైరెక్టరీకి మరియు ఒక సెషన్ తాత్కాలిక డైరెక్టరీకి మాత్రమే రాయగలదు. అలాగే, ప్రతి డొమైన్‌ను అనుమతించబడిన జాబితాతో (allow list) సరిచూసే ప్రాక్సీ ద్వారా మాత్రమే అది నెట్‌వర్క్‌ను చేరుకోగలదు. ఒక కమాండ్ కొత్త డొమైన్‌ను కోరినప్పుడు, Claude Code మిమ్మల్ని అడుగుతుంది.

సెషన్ లోపల /sandbox కమాండ్‌తో దీన్ని ఆన్ చేయండి. Ubuntu మరియు Debianలలో, దీనికి అవసరమైన రెండు ప్యాకేజీలను ముందుగా ఇన్‌స్టాల్ చేయండి:

sudo apt install bubblewrap socat

Ubuntu 24.04 మరియు ఆ తర్వాతి వెర్షన్లలో, డిఫాల్ట్ AppArmor పాలసీ bubblewrapకు అవసరమైన యూజర్ నేమ్‌స్పేస్‌లను సృష్టించకుండా అడ్డుకుంటుంది. ఏదైనా లోపించినప్పుడు శాండ్‌బాక్స్ ప్యానెల్ మీకు తెలియజేస్తుంది, మరియు Claude Code శాండ్‌బాక్సింగ్ డాక్యుమెంటేషన్‌లో దీన్ని సరిచేసే చిన్న AppArmor ప్రొఫైల్ అందుబాటులో ఉంటుంది.

ఈ శాండ్‌బాక్స్‌లో ఆటో-అలో (auto-allow) మోడ్ ఉంది: శాండ్‌బాక్స్ కమాండ్లు ఎటువంటి ప్రాంప్ట్ లేకుండానే రన్ అవుతాయి, ఎందుకంటే గతంలో ప్రాంప్ట్ చేసే పనిని ఇప్పుడు అమలు చేయబడిన పరిమితులు (enforced boundary) చేస్తున్నాయి. శాండ్‌బాక్స్ లోపల రన్ అవ్వలేని కమాండ్లు సాధారణ అనుమతుల విధానానికి (normal permission flow) మళ్లుతాయి, కాబట్టి అసాధారణమైన చర్యల కోసం ఇప్పటికీ మిమ్మల్ని అడుగుతుంది. చాలా సర్వర్ వర్క్‌ఫ్లోలకు ఇది skip ఫ్లాగ్‌కు సరైన ప్రత్యామ్నాయం, ఎందుకంటే ఏమీ లేని స్థితి కంటే OS-అమలు చేసే పరిమితితో మీకు చాలా తక్కువ ప్రశ్నలు ఎదురవుతాయి.

దీని పరిమితుల గురించి నిజాయితీగా ఉండండి. డిఫాల్ట్‌గా, శాండ్‌బాక్స్ కమాండ్ ఇప్పటికీ ఫైల్‌సిస్టమ్‌లోని చాలా భాగాలను, క్రెడెన్షియల్ ఫైళ్లతో సహా చదవగలదు; మీరు ఆ పాత్‌లను నిరాకరిస్తే తప్ప. sandbox.credentials సెట్టింగ్ సరిగ్గా దీని కోసమే ఉంది. నెట్‌వర్క్ ప్రాక్సీ డొమైన్ పేర్లను మాత్రమే తనిఖీ చేస్తుంది, ట్రాఫిక్‌ను స్వయంగా పరిశీలించదు. కాబట్టి github.com వంటి విస్తృత అనుమతి డేటాను బయటకు పంపే అవకాశం కల్పిస్తుంది. దీని లోపల Docker పనిచేయదు. శాండ్‌బాక్స్ భద్రతా ప్రమాణాలను గణనీయంగా పెంచుతుంది, కానీ ఇది పూర్తి స్థాయి ఐసోలేషన్ బౌండరీ కాదు, అందుకే కింద పేర్కొన్న దశలు ఇప్పటికీ ముఖ్యమైనవి.

కంటైన్‌మెంట్ నిచ్చెన

ఐసోలేషన్ స్థాయిని బట్టి మూడు మెట్లు ఉన్నాయి. మీ సర్వర్‌లో ఉన్న ఇతర సేవల అవసరాలకు అనుగుణంగా తక్కువ స్థాయి మెట్టును ఎంచుకోండి.

మెట్టు 1: ప్రత్యేకమైన unprivileged user. ఏజెంట్‌కు ఒక ప్రత్యేక ఖాతా, దాని సొంత home directory, ప్రాజెక్ట్ డైరెక్టరీ కేటాయించాలి. దీనికి sudo అనుమతులు ఉండకూడదు:

sudo adduser --disabled-password --gecos "" agent

ఈ ఖాతా పరిమితి వల్ల మీ ఫైళ్లు, SSH keys మరియు సర్వర్‌లోని ఇతర ప్రాజెక్టులు ఏజెంట్ బారిన పడకుండా ఉంటాయి. ఇది skip ఫ్లాగ్‌ను ఉపయోగించడానికి కూడా వీలు కల్పిస్తుంది, ఎందుకంటే root యూజర్‌గా రన్ అవ్వడానికి ఈ ఫ్లాగ్ అనుమతించదు. ఇది ప్రతి సేవను unprivileged userగా రన్ చేయడం అనే సూత్రంపైనే ఆధారపడి ఉంటుంది. మెట్టు 1 నెట్‌వర్క్‌ను మరియు సర్వర్‌లో అందరికీ అందుబాటులో (world-readable) ఉన్న ఫైళ్లను నియంత్రించలేదు.

మెట్టు 2: కంటైనర్. Anthropic ఒక reference devcontainer ను అందిస్తుంది. ఇది Claude Code ను non-root యూజర్‌గా రన్ చేస్తుంది. ఫైర్‌వాల్ నియమాల ద్వారా ఏజెంట్ ఏ హోస్ట్‌లను చేరుకోవాలో పరిమితం చేయవచ్చు. మీరు సొంతంగా తయారు చేసుకునే కంటైనర్ కూడా ఇదే పని చేస్తుంది. ఫైల్‌సిస్టమ్ మీరు మౌంట్ చేసిన వాల్యూమ్‌లకు మాత్రమే పరిమితమవుతుంది, అలాగే బయటకు వెళ్లే ట్రాఫిక్ (egress) కంటైనర్ నియమాల ప్రకారం నియంత్రించబడుతుంది. మీ సర్వర్‌లో ఇతర ముఖ్యమైన సేవలు ఉన్నప్పుడు ఇది సరైన మధ్యస్థ మెట్టు. అయితే, కంటైనర్లు హోస్ట్ కెర్నల్‌ను పంచుకుంటాయి; ఒక పొరపాటున చేసే మౌంట్ ఈ రక్షణను తొలగిస్తుంది. కంటైనర్‌కు /var/run/docker.sock ఇస్తే, అది మొత్తం హోస్ట్‌ను యాక్సెస్ చేయగలదు.

మెట్టు 3: ప్రత్యేకమైన VPS. అత్యంత బలమైన మరియు సులభమైన మార్గం: ఏజెంట్ కోసం ఒక ప్రత్యేక మెషీన్‌ను కేటాయించండి. ఇందులో మీకు ముఖ్యమైన డేటా ఏదీ ఉండకూడదు. ఒక చిన్న VPS నెలకు కొన్ని డాలర్లకే లభిస్తుంది. దీన్ని కొత్త VPS సెటప్ చేసే మొదటి పది నిమిషాల రన్‌బుక్ ప్రకారం సిద్ధం చేయండి, ఆపై క్లీన్ స్టేట్‌ను snapshot తీసుకోండి. అక్కడ ఏజెంట్ తప్ప మరేమీ ఉండకూడదు. వ్యక్తిగత SSH key ఉండకూడదు, కేవలం ఒక రిపోజిటరీకి మాత్రమే పరిమితమైన deploy key ఉండాలి. క్లౌడ్ క్రెడెన్షియల్స్ లేదా ప్రొడక్షన్ డేటా ఉండకూడదు. ఏదైనా తేడా జరిగినా లేదా మీకు మళ్ళీ కొత్తగా ప్రారంభించాలని అనిపించినా, snapshot ను restore చేయండి లేదా నిమిషాల్లో సర్వర్‌ను తొలగించి మళ్ళీ నిర్మించండి. దీనివల్ల కలిగే నష్టం కేవలం ఆ సర్వర్ అద్దె మాత్రమే. ఈ సెటప్‌లో --dangerously-skip-permissions భయంకరంగా అనిపించదు, ఎందుకంటే అత్యంత దారుణమైన పరిస్థితిలో కూడా సర్వర్‌ను మళ్ళీ నిర్మించడం మరియు ఒక టోకెన్‌ను రద్దు చేయడం మాత్రమే చేయాల్సి ఉంటుంది.

ఈ మెట్లు ఒకదానిపై ఒకటి ఉంటాయి. ఒక disposable VPS లో, unprivileged user గా రన్ అయ్యే sandboxed ఏజెంట్ వల్ల అదనపు ఖర్చు దాదాపు ఉండదు, అలాగే భద్రతా పరమైన వైఫల్యాలు కూడా తక్కువగా ఉంటాయి. మన లక్ష్యం కూడా ఇదే: భద్రత విషయంలో బోర్ కొట్టేంత సురక్షితంగా ఉండటం.

క్రెడెన్షియల్స్‌ను సురక్షితంగా ఉంచడం

మిగిలిన అన్నింటికంటే ముఖ్యమైన నియమం: ఏజెంట్ వినియోగదారుడు ఇతర దేనికి సంబంధించిన రహస్యాలను (secrets) చదవకూడదు.

API కీని ఏజెంట్‌కు మాత్రమే ఇవ్వండి, మరే ఇతర సేవకు ఇవ్వకండి. దీనిని ఏజెంట్ వినియోగదారుని యాజమాన్యంలో ఉండి, 600 మోడ్‌లో ఉన్న ఫైల్‌లో ఉంచండి. షెల్ ప్రారంభమైనప్పుడు దానిని లోడ్ చేయండి:

install -m 600 /dev/null /home/agent/claude.env
echo 'export ANTHROPIC_API_KEY=your-key-here' >> /home/agent/claude.env
echo 'source ~/claude.env' >> /home/agent/.bashrc

ఆ తర్వాత ఇతర మార్గాలను మూసివేయండి. Debian మరియు Ubuntu లలో, హోమ్ డైరెక్టరీలు తరచుగా సిస్టమ్‌లోని ప్రతి వినియోగదారునికి చదవగలిగేలా (readable) ఉంటాయి, కాబట్టి మీ డైరెక్టరీని సురక్షితం చేయండి: chmod 750 /home/youruser. ls -ld /home/* తో తనిఖీ చేయండి మరియు ఏజెంట్ ఖాతా ద్వారా చూడగలిగే ఏవైనా ఫైల్స్ ఉంటే వాటిని సరిచేయండి.

ప్రతి టోకెన్‌కు పరిధిని (scope) నిర్ణయించండి. ఒకే రిపోజిటరీకి పరిమితం చేయబడిన ఫైన్-గ్రెయిన్డ్ GitHub టోకెన్ లేదా ప్రతి రిపోజిటరీకి విడివిడిగా ఉండే డిప్లాయ్ కీని వాడటం వల్ల, ఒకవేళ క్రెడెన్షియల్ లీక్ అయినా మీ మొత్తం ఖాతా కాకుండా కేవలం ఒక ప్రాజెక్ట్ మాత్రమే ప్రభావితమవుతుంది. మీరు శాండ్‌బాక్స్‌ను ఉపయోగిస్తుంటే, దాని క్రెడెన్షియల్ సెట్టింగ్‌లను జోడించండి, తద్వారా ~/.ssh మరియు ~/.aws రీడ్ ఆపరేషన్లకు కూడా అనుమతించబడవు. ప్రొడక్షన్ క్రెడెన్షియల్స్‌ను ఆ బాక్స్‌లో ఉంచకండి, ఎందుకంటే అక్కడ లేని రహస్యాన్ని ఏజెంట్ లీక్ చేయలేదు. ఒకవేళ ఆ రహస్యాలు సెల్ఫ్-హోస్టెడ్ పాస్‌వర్డ్ మేనేజర్‌లో ఉంటే, దానిని ఏజెంట్ ఉన్న బాక్స్‌లో కాకుండా వేరే బాక్స్‌లో ఉంచండి మరియు దానిని ప్రత్యేకంగా సమీక్షించండి, ఎందుకంటే Vaultwarden యొక్క బలహీనతలు అడ్మిన్ టోకెన్ మరియు బ్యాకప్ ఫైల్ లో ఉంటాయి, ఎన్‌క్రిప్ట్ చేయబడిన వాల్ట్ (vault) లో కాదు.

Git ఒక రక్షణ కవచం

ఏజెంట్ చేసే ప్రతి మార్పును సమీక్షించేలా మరియు వెనక్కి తీసుకునేలా (revert) ఉండాలి. ఏజెంట్ ఒక ప్రత్యేక branch లో పనిచేస్తే, git ఈ రెండు సౌకర్యాలను ఉచితంగా అందిస్తుంది:

git switch -c agent/refactor-auth

తర్వాత git diff main...agent/refactor-auth ఉపయోగించి రన్‌ను సమీక్షించండి, మంచి మార్పులను merge చేయండి, ఒకవేళ ఆ రన్ వల్ల ప్రయోజనం లేకపోతే branch ను తొలగించండి. మూడు ఫైళ్లను మార్చిన రన్‌ను ఉదయం పూట చదవడం, మాడ్యూల్‌లో సగం మార్చిన దానికంటే చాలా సులభం. ఇదే ఏజెంట్ పని చేసే అతి చిన్న మార్పుకే పరిమితం చేసే నైపుణ్యం యొక్క ఆచరణాత్మక ఉద్దేశ్యం. Git forge వైపు main branch ను రక్షించండి (protect), తద్వారా ఏజెంట్ టోకెన్ దానికి push చేయలేకపోవడమే కాకుండా, ఎక్కడా force-push చేయకుండా నిరోధించబడుతుంది. మీరు నిద్రపోతున్నప్పుడు ఏమి జరిగిందో తెలుసుకోవడానికి commit history ఒక audit log వలె పనిచేస్తుంది, ఇది terminal scrollback కంటే ఎంతో విలువైనది.

నెట్‌వర్క్ అనేది బ్లాస్ట్ రేడియస్‌లో ఒక భాగం

ఒక ఏజెంట్ curlని రన్ చేయగలదు. ఆ వాక్యం మొత్తం ఎగ్రెస్ (egress) సమస్యను తెలియజేస్తుంది: ఏజెంట్ దేనినైతే చదవగలదో, దానిని ఎక్కడికైనా పంపగలదు, ప్రాంప్ట్-ఇంజెక్ట్ అయిన ఏజెంట్ అలా చేసే అవకాశం ఉంది. సాధారణ ప్రివిలేజ్ లేని యూజర్ దీనిని ఏమాత్రం నియంత్రించలేరు, ఎందుకంటే సర్వర్ దేనినైతే చేరుకోగలదో, దానిని ఏ యూజర్ అయినా చేరుకోగలరు. శాండ్‌బాక్స్ (sandbox) దాని ప్రాక్సీ ద్వారా డొమైన్ స్థాయిలో దీనిని నియంత్రిస్తుంది. ఒక కంటైనర్ దాని స్వంత ఫైర్‌వాల్ నియమాలతో దీనిని నియంత్రించగలదు. ఒక ప్రత్యేకమైన VPS, లీక్ కావడానికి ఏమీ లేకుండా చేయడం ద్వారా దీనిని నియంత్రిస్తుంది, ఇది మూడింటిలో అత్యంత పటిష్టమైన పరిష్కారం.

కేవలం ufw తో మాత్రమే ఎగ్రెస్ సమస్యను పరిష్కరించడానికి ప్రయత్నించకండి. ufw డిఫాల్ట్‌గా అన్ని అవుట్‌గోయింగ్ ట్రాఫిక్‌ను అనుమతిస్తుంది, మరియు apt, npm, git, మరియు Claude API లను అనుమతిస్తూ అవుట్‌బౌండ్ నియమాలను రాయడం చాలా క్లిష్టమైన పని, ఇది ఎటువంటి హెచ్చరిక లేకుండా విఫలమవుతుంది. దానికి బదులుగా శాండ్‌బాక్స్, కంటైనర్ లేదా మెషీన్ స్థాయిలో సరిహద్దును నిర్ణయించుకోండి, అక్కడ డొమైన్ అలో-లిస్ట్ లేదా ఖాళీ మెషీన్ అదే పనిని సులభంగా పూర్తి చేస్తాయి.

మీరు Claude Codeని రన్ చేయడానికి బదులుగా, APIని ఉపయోగించి మీ స్వంత ఏజెంట్‌ను నిర్మిస్తుంటే, ఇదే ఆలోచన వర్తిస్తుంది. VPSలో Claudeతో AI ఏజెంట్‌ను నిర్మించడం అనే విభాగం ఆ మార్గాన్ని వివరిస్తుంది, మరియు ఆ ఏజెంట్‌కు కూడా అదే ప్రత్యేక యూజర్, అదే పరిమిత టోకెన్లు, మరియు అదే డిస్పోజబుల్ బాక్స్ అవసరం.

ముందుగా సర్వర్‌ను సురక్షితం చేయండి (Harden the box first)

మీరు ఏ పద్ధతిని ఎంచుకున్నా, ఏజెంట్‌ను ఇన్‌స్టాల్ చేసే ముందు సర్వర్‌కు కనీస భద్రతా ప్రమాణాలు అవసరం: కేవలం SSH keys మాత్రమే వాడాలి, root login నిలిపివేయాలి, default-deny firewall ఉండాలి, మరియు ఆటోమేటిక్ సెక్యూరిటీ అప్‌డేట్స్ అమర్చాలి. మీ చెక్‌లిస్ట్‌ను ఇక్కడ రూపొందించుకుని, ఒక్కొక్కటిగా పూర్తి చేయండి:

FAQ

--dangerously-skip-permissions ను సర్వర్‌లో ఉపయోగించడం సురక్షితమేనా?

కేవలం దీనిని ఉపయోగించడం సురక్షితం కాదు. ఈ flag ప్రతి అనుమతి అభ్యర్థనను (approval prompt) తొలగిస్తుంది, కాబట్టి మోడల్ ఏదైనా తప్పు కమాండ్‌ను రూపొందించిన వెంటనే అది అమలు అవుతుంది. దీని ప్రభావం పరిమితంగా ఉన్నప్పుడు మాత్రమే ఇది ఆమోదయోగ్యమైన పద్ధతి: కనీసం ఒక ప్రత్యేకమైన unprivileged user ను ఉపయోగించడం, మరియు పూర్తిగా పర్యవేక్షణ లేని పనుల కోసం ఒక container లేదా ఒక ప్రాజెక్ట్ మరియు పరిమితమైన token మాత్రమే ఉన్న disposable VPS ను వాడటం మంచిది. ప్రొడక్షన్ క్రెడెన్షియల్స్ లేదా మీరు కోల్పోకూడని డేటా ఉన్న మెషీన్‌పై దీనిని ఎప్పుడూ ఉపయోగించవద్దు.

Claude Code కు sandbox ఉందా?

అవును. Claude Code లో shell కమాండ్ల కోసం అంతర్నిర్మిత sandbox ఉంది, దీనిని /sandbox కమాండ్‌తో తెరవవచ్చు. ఇది Linux లో bubblewrap ను, macOS లో Seatbelt ను ఉపయోగిస్తుంది. ఇది ప్రాజెక్ట్ డైరెక్టరీకి మాత్రమే రైటింగ్ అనుమతులను పరిమితం చేస్తుంది మరియు ఆమోదించబడిన డొమైన్‌లకు మాత్రమే నెట్‌వర్క్ యాక్సెస్‌ను అనుమతించే proxy ద్వారా రూట్ చేస్తుంది. దీని auto-allow మోడ్ అభ్యర్థనలు లేకుండానే sandboxed కమాండ్లను అమలు చేస్తుంది, కాబట్టి ఇది skip flag లాగే అంతరాయాలను తగ్గిస్తూనే OS-స్థాయి భద్రతను అందిస్తుంది. ఇది పూర్తి స్థాయి ఐసోలేషన్ కాదు, కాబట్టి పర్యవేక్షణ లేని పనుల కోసం దీనిని ఒక ప్రత్యేక user లేదా ప్రత్యేక మెషీన్‌తో కలిపి వాడండి.

root గా ఉన్నప్పుడు skip flag ఎందుకు పనిచేయదు?

root యూజర్‌కు ఎటువంటి అనుమతి అభ్యర్థనలు లేకుండా సిస్టమ్‌లోని ఏ ఫైల్‌నైనా లేదా ఏ సర్వీస్‌నైనా మార్చే అధికారం ఉంటుంది, అందుకే Linux మరియు macOS లలో root గా లేదా sudo తో రన్ చేసినప్పుడు Claude Code --dangerously-skip-permissions ను నిరోధిస్తుంది. ఈ తనిఖీని దాటవేయడానికి ప్రయత్నించవద్దు. ఏజెంట్ కోసం ఒక unprivileged user ను సృష్టించి అక్కడ రన్ చేయండి; ఆ అకౌంట్ బౌండరీనే భద్రతకు మొదటి మరియు అత్యంత చౌకైన మార్గం.

Claude Code నా SSH keys మరియు .env ఫైళ్లను చదవగలదా?

ఏ యూజర్ అకౌంట్‌తో అది రన్ అవుతుందో, ఆ యూజర్‌కు యాక్సెస్ ఉన్న దేనినైనా అది చదవగలదు. sandbox యొక్క డిఫాల్ట్ పాలసీ కూడా మీరు నిరాకరించే వరకు క్రెడెన్షియల్ పాత్‌లను చదవడానికి అనుమతిస్తుంది. కాబట్టి ఏజెంట్‌ను దాని సొంత యూజర్ అకౌంట్‌తో రన్ చేయండి, మీ హోమ్ డైరెక్టరీని 750 లేదా అంతకంటే కఠినమైన మోడ్‌లో ఉంచండి, sandbox సెట్టింగ్‌లలో క్రెడెన్షియల్ పాత్‌లను నిరాకరించండి మరియు ప్రొడక్షన్ సీక్రెట్స్‌ను ఆ మెషీన్‌పై ఉంచకండి. ఒక సీక్రెట్ ఆ బాక్స్‌లోకి రానంత వరకు, అది చదవబడదు లేదా లీక్ అవ్వదు.

Claude Code ను పర్యవేక్షణ లేకుండా రన్ చేయడానికి అత్యంత సురక్షితమైన మార్గం ఏమిటి?

ఏజెంట్ పనుల కోసం మాత్రమే ఉపయోగించే ఒక చౌకైన dedicated VPS: పది నిమిషాల్లో హార్డెన్ చేసి, క్లీన్ స్నాప్‌షాట్ తీసుకుని, unprivileged user తో sandbox ఆన్ చేసి Claude Code ను రన్ చేయండి. API key ని 600 మోడ్ ఉన్న ఫైల్‌లో ఉంచండి, ప్రతి రిపోజిటరీకి ఒక ప్రత్యేక deploy key ని వాడండి మరియు మెర్జ్ చేసే ముందు మీరు రివ్యూ చేసే బ్రాంచ్‌లపైనే అన్ని పనులు చేయండి. ఒకవేళ ఏదైనా తప్పు జరిగితే, మీరు ఒక టోకెన్‌ను రద్దు చేసి స్నాప్‌షాట్‌ను పునరుద్ధరించవచ్చు, దీనివల్ల మీకు చెందిన మరే ఇతర డేటా ప్రభావితం కాదు.