SSD Nodes Learn Hosting plans →
మార్గదర్శకాలు Matt Connorద్వారా Matt Connor · అప్‌డేట్ చేయబడింది 2026-11-06

Ubuntu 24.04లో GitHub Actions runner సెటప్ చేయడం ఎలా?

Ubuntu 24.04 VPSలో GitHub Actions runnerను ఎలా కాన్ఫిగర్ చేయాలో తెలుసుకోండి. చెక్‌సమ్ వెరిఫికేషన్, systemd సర్వీస్ సెటప్ మరియు ఫోర్క్ పుల్ రిక్వెస్ట్ భద్రతా ప్రమాదాల గురించి వివరణ.

Verified Every command ran end-to-end on a fresh Ubuntu 24.04 server, July 30, 2026.

Self-hosted GitHub Actions runner అంటే ఏమిటి

Self-hosted GitHub Actions runner అనేది మీరు మీ సొంత VPSలో ఇన్‌స్టాల్ చేసుకునే ఒక ప్రోగ్రామ్. ఇది GitHub నుండి పనులను (jobs) అడిగి, వాటిని మీ హార్డ్‌వేర్‌పై రన్ చేస్తుంది. మీరు దీన్ని ఒక రిపోజిటరీకి రిజిస్టర్ చేసి, systemd సర్వీస్‌గా ఇన్‌స్టాల్ చేస్తారు, తద్వారా ప్రతి రీబూట్ తర్వాత ఇది ఆటోమేటిక్‌గా ప్రారంభమవుతుంది. GitHub పనులను షెడ్యూల్ చేస్తుంది, మీ సర్వర్ ఆ పనిని పూర్తి చేస్తుంది.

మీ సొంత సర్వర్‌పై CI (continuous integration) నిర్వహించడం రెండు కారణాల వల్ల ఉపయోగకరం. బిల్డ్ నిమిషాలకు (build minutes) పరిమితి ఉండదు, మరియు మీ మెషీన్‌కు మాత్రమే అందుబాటులో ఉండే బిల్డ్ క్యాచీ (build cache) లేదా ప్రైవేట్ నెట్‌వర్క్ వంటి వనరులను ఈ జాబ్ ఉపయోగించుకోగలదు. దీనికి చెల్లించాల్సిన మూల్యం భద్రత. మీరు ఇచ్చిన యూజర్ అనుమతులతో, వర్క్‌ఫ్లో ఫైల్‌లో ఉన్న ఏ కోడ్‌నైనా ఈ రన్నర్ అమలు చేస్తుంది; కాబట్టి వర్క్‌ఫ్లో ఫైల్ అనేది డిజైన్ పరంగానే రిమోట్ కోడ్ ఎగ్జిక్యూషన్ (remote code execution) అవుతుంది. ప్రైవేట్ రిపోజిటరీలో, వర్క్‌ఫ్లోలను రన్ చేసే ఎవరినైనా మీరు నమ్మాలి, ఇందులో ఫోర్క్ పుల్ రిక్వెస్ట్‌లను సబ్మిట్ చేసే వారు కూడా ఉంటారు. పబ్లిక్ రిపోజిటరీలో ఇది చాలా ప్రమాదకరం, దీనికి సంబంధించిన మెకానిజం గురించి ఫోర్క్ పుల్ రిక్వెస్ట్‌ల విభాగంలో వివరించబడింది.

కింద ఉన్న సమాచారం అంతా Ubuntu 24.04 మరియు runner వెర్షన్ 2.338.0 కి సంబంధించినది, ఇది 12 అక్టోబర్ 2026 నాటికి ఉన్న తాజా విడుదల. 4 నవంబర్ 2026 నాటికి GitHub యొక్క తాజా విడుదల 2.338.2 అయినప్పటికీ, కింద పేర్కొన్న కమాండ్లు మరియు చెక్‌సమ్ 2.338.0 వెర్షన్‌కే పరిమితం చేయబడ్డాయి.

మీరు ప్రారంభించడానికి ముందు మీకు కావలసినవి

సాధారణ అడ్మిన్ ఖాతా మరియు sudo సౌకర్యం ఉన్న VPSతో ప్రారంభించండి, ఇది కొత్త VPSలో మొదటి పది నిమిషాలు అనే విభాగంలో మీరు పొందే స్థితి. మీరు ఇన్‌బౌండ్ పోర్ట్‌ను తెరవాల్సిన అవసరం లేదు. రన్నర్ GitHubకి అవుట్‌బౌండ్ HTTPS (హైపర్‌టెక్స్ట్ ట్రాన్స్‌ఫర్ ప్రోటోకాల్ సెక్యూర్) కనెక్షన్‌ను తెరుస్తుంది మరియు పని కోసం వేచి ఉన్నప్పుడు దానిని అలాగే ఉంచుతుంది, కాబట్టి GitHub మీ సర్వర్‌కు ఎప్పటికీ కనెక్ట్ అవ్వదు. మీ ఫైర్‌వాల్ ప్రపంచానికి మూసివేయబడి ఉన్నప్పటికీ జాబ్‌లు అందుతాయి.

మీకు రిపోజిటరీపై అడ్మిన్ హక్కులు కూడా ఉండాలి, ఎందుకంటే రిజిస్ట్రేషన్ టోకెన్ రిపోజిటరీ సెట్టింగ్‌లలో కనిపిస్తుంది.

రన్నర్ కోసం ప్రత్యేక వినియోగదారుని సృష్టించండి

రన్నర్‌ను ఎప్పుడూ rootగా లేదా మీ స్వంత అడ్మిన్ వినియోగదారుగా రన్ చేయవద్దు. ప్రతి జాబ్ రన్నర్ వినియోగదారు యొక్క హక్కులను పొందుతుంది, కాబట్టి sudoని పిలిచే వర్క్‌ఫ్లో, రన్నర్ వినియోగదారు sudoని ఉపయోగించగలిగితే విజయవంతమవుతుంది. తన సొంత హోమ్ డైరెక్టరీ తప్ప మరేమీ లేని ఒక అన్‌ప్రివిలేజ్డ్ (తక్కువ అధికారాలు కలిగిన) వినియోగదారుని సృష్టించండి. VPSలో కనీస అధికారాలు కలిగిన వినియోగదారు ఖాతాలు సాధారణ పద్ధతిని వివరిస్తుంది. ఇక్కడ నిర్దిష్టమైన పద్ధతి ఉంది.

sudo useradd -m -s /bin/bash gharunner
sudo passwd -l gharunner
sudo chmod 750 /home/gharunner
sudo install -d -m 700 -o gharunner -g gharunner /home/gharunner/actions-runner

passwd -l పాస్‌వర్డ్‌ను లాక్ చేస్తుంది, కాబట్టి ఎవరూ gharunnerగా పాస్‌వర్డ్‌తో లాగిన్ అవ్వలేరు. రన్నర్ డైరెక్టరీపై 700 మోడ్ ముఖ్యం, ఎందుకంటే రన్నర్ తన క్రెడెన్షియల్స్‌ను అక్కడ ప్లెయిన్‌టెక్స్ట్‌లో నిల్వ చేస్తుంది మరియు చెకౌట్ ప్రైవేట్ సోర్స్‌ను కలిగి ఉండవచ్చు.

మీరు ముందుకు వెళ్లే ముందు రెండు లక్షణాలను తనిఖీ చేయండి:

sudo passwd -S gharunner
sudo -l -U gharunner

passwd -S అనేది gharunner Lతో ప్రారంభమయ్యే ఒక లైన్‌ను ప్రింట్ చేస్తుంది, ఇక్కడ L అంటే పాస్‌వర్డ్ లాక్ చేయబడిందని అర్థం. sudo -l -U gharunner అనేది is not allowed to run sudoతో సమాధానం ఇవ్వాలి. ఒకవేళ అది అనుమతించబడిన కమాండ్ల జాబితాను ప్రింట్ చేస్తే, ఆ ఖాతా sudo గ్రూపులో ఉందని మరియు మీరు ఇప్పుడే నిర్మించిన ఐసోలేషన్ పోయిందని అర్థం.

runner ను డౌన్‌లోడ్ చేసి tarball ను తనిఖీ చేయండి

ఇక్కడి నుంచి runner user గా పని చేయండి.

sudo -iu gharunner
cd ~/actions-runner
RUNNER_VERSION=2.338.0
curl -fL -o actions-runner-linux-x64-${RUNNER_VERSION}.tar.gz \
  "https://github.com/actions/runner/releases/download/v${RUNNER_VERSION}/actions-runner-linux-x64-${RUNNER_VERSION}.tar.gz"

Architecture పై స్పష్టత లేకపోతే ముందుగా uname -m ను అమలు చేయండి. x86_64 పై ఉన్న linux-x64 file ను తీసుకుంటుంది. aarch64, actions-runner-linux-arm64-${RUNNER_VERSION}.tar.gz ను తీసుకుంటుంది.

ఇప్పుడు మీరు డౌన్‌లోడ్ చేసిన దాన్ని ధృవీకరించండి. కింది SHA256 (secure hash algorithm, 256 bit) విలువ 2.338.0 x64 tarball కోసం ఉంది. GitHub ప్రస్తుత release కోసం ఈ విలువను release page మరియు New self-hosted runner screen పై చూపిస్తుంది. ప్రతి version తో ఇది మారుతుంది. వేరే version ను install చేసేటప్పుడు అక్కడి నుంచి విలువను copy చేయండి.

echo "af4b794c1bc41d73d40535e3fe092a39f9679cd8d965954c2aca25a05ca41d32  actions-runner-linux-x64-2.338.0.tar.gz" | sha256sum -c

డౌన్‌లోడ్ సరిగ్గా జరిగితే ఒక line ముద్రించబడుతుంది:

actions-runner-linux-x64-2.338.0.tar.gz: OK

కత్తిరించబడిన లేదా మార్చబడిన file failure మరియు warning ను ముద్రిస్తుంది:

actions-runner-linux-x64-2.338.0.tar.gz: FAILED
sha256sum: WARNING: 1 computed checksum did NOT match

ఈ తనిఖీని దాటవేసి, సమస్యను tar కనుగొంటుందని ఆశించవద్దు. సగం మాత్రమే వ్రాయబడిన archive gzip: stdin: unexpected end of file మరియు tar: Unexpected EOF in archive తో విఫలమవుతుంది. దీనివల్ల file పాడైందని తెలుస్తుంది, కానీ అది మధ్యలోనే కత్తిరించబడిందా లేదా దాని స్థానంలో వేరే file పెట్టబడిందా అనేది తెలియదు.

tar xzf ./actions-runner-linux-x64-2.338.0.tar.gz
ls

టార్‌బాల్‌లో ఏముంది, ఏముండదు

ఎక్స్‌ట్రాక్ట్ చేసిన తర్వాత, ఆ డైరెక్టరీలో config.sh, run.sh, env.sh, safe_sleep.sh, bin/ మరియు externals/ ఉంటాయి. bin/ లో రన్నర్ బైనరీలు మరియు bin/installdependencies.sh ఉంటాయి. externals/ లో JavaScript యాక్షన్‌లు రన్ అయ్యే బండిల్డ్ Node రన్‌టైమ్ ఉంటుంది.

ఇప్పటికి svc.sh అందుబాటులో ఉండదు. GitHub డాక్యుమెంటేషన్ ప్రకారం, ఇది "రన్నర్‌ను విజయవంతంగా జోడించిన తర్వాత సృష్టించబడే" స్క్రిప్ట్. ఎందుకంటే, మీ రిపోజిటరీ మరియు రన్నర్ పేరును సర్వీస్ పేరులో చేర్చి, ఒక టెంప్లేట్ నుండి దీనిని రూపొందిస్తారు. కాబట్టి, ./config.sh కంటే ముందు sudo ./svc.sh install రన్ చేస్తే, అది sudo: ./svc.sh: command not found తో విఫలమవుతుంది. ముందుగా రిజిస్టర్ చేయండి, ఆ తర్వాత సర్వీస్‌ను ఇన్‌స్టాల్ చేయండి.

Runner డిపెండెన్సీలను ఇన్‌స్టాల్ చేయండి

Runner అనేది ఒక .NET అప్లికేషన్, కాబట్టి దీనికి కొన్ని షేర్డ్ లైబ్రరీలు అవసరం. Runner యూజర్ యొక్క షెల్ నుండి బయటకు వచ్చి, sudo ఉపయోగించి వీటిని ఇన్‌స్టాల్ చేయండి, ఎందుకంటే ఈ స్క్రిప్ట్ సిస్టమ్ ప్యాకేజీ డేటాబేస్‌లో మార్పులు చేస్తుంది.

exit
cd /home/gharunner/actions-runner
sudo ./bin/installdependencies.sh

Ubuntu 24.04లో ఇది libkrb5-3, zlib1g, liblttng-ust1t64, libssl3t64 మరియు libicu74 లను తీసుకుంటుంది. ఈ స్క్రిప్ట్ ప్రతి లైబ్రరీ కోసం వివిధ వెర్షన్ పేర్లను ప్రయత్నించి, మీ రిలీజ్ వెర్షన్‌లో ఉన్న దానిని ఎంచుకుంటుంది; అందుకే ఇదే స్క్రిప్ట్ పాత Ubuntu మరియు Debian వెర్షన్లలో కూడా పనిచేస్తుంది.

ldd ద్వారా తనిఖీ చేసిన లైబ్రరీ అందుబాటులో లేకపోతే, Runner ప్రారంభం కావడానికి ముందే ./config.sh ఆగిపోతుంది:

Dependencies is missing for Dotnet Core 6.0
Execute sudo ./bin/installdependencies.sh to install any missing Dotnet Core 6.0 dependencies.

libicu లేకపోతే, అది Libicu's dependencies is missing for Dotnet Core 6.0 అనే వేరే మొదటి లైన్ కింద అదే సలహాను ఇస్తుంది. ఇవి రెండూ ఒకే చోట నుండి వస్తాయి: config.sh, Runner ప్రారంభం కావడానికి ముందే ldd తో బండిల్ చేయబడిన లైబ్రరీలను మరియు ldconfig తో libicu ను తనిఖీ చేస్తుంది. కాబట్టి, ఏదైనా లింక్ రిజాల్వ్ కాకపోతే, తర్వాత గందరగోళంగా క్రాష్ అయ్యే బదులు, స్క్రిప్ట్ అక్కడే ఆగిపోతుంది. ఈ తనిఖీలు ఇన్‌స్టాలర్ పేర్కొన్న అన్ని ప్యాకేజీలను కవర్ చేయవు. liblttng-ust1t64 లేకపోవడం వల్ల ఇవి ట్రిగ్గర్ కావు: .NET అనేది LTTng ట్రేసింగ్‌ను ఆప్షనల్‌గా లోడ్ చేస్తుంది మరియు దాని ట్రేసింగ్ డిపెండెన్సీలు అందుబాటులో లేనప్పుడు కూడా రన్ అవుతూనే ఉంటుంది.

మీ repositoryతో runnerను నమోదు చేయండి

repository నుంచి token పొందండి. Settings తెరిచి, తర్వాత Actions, తర్వాత Runners, తర్వాత New self-hosted runner ఎంచుకోండి. ఆ పేజీలో registration token కనిపిస్తుంది. Token సృష్టించిన ఒక గంట తర్వాత అది expire అవుతుంది. కాబట్టి దాన్ని commandలో paste చేయడానికి సిద్ధంగా ఉన్నప్పుడే generate చేయండి.

runner userగా register చేయండి. config.shను sudoతో run చేయడం సాధ్యం కాదు.

sudo -iu gharunner
cd ~/actions-runner
./config.sh --url https://github.com/YOUR-USER/YOUR-REPO \
  --token PASTE_REGISTRATION_TOKEN_HERE \
  --name vps-runner-1 \
  --labels vps \
  --work _work \
  --unattended \
  --replace

ఈ flags చేసే పని. repositoryలో runner ఎలా కనిపించాలో --name నిర్ణయిస్తుంది. కాబట్టి ఆరు నెలల తర్వాత కూడా గుర్తించగలిగే పేరును ఎంచుకోండి. --labels మీ స్వంత labelsను జోడిస్తుంది. అడగకపోయినా runnerకు self-hosted, Linux మరియు X64 ఇప్పటికే ఉంటాయి. checkout చేసిన files ఎక్కడ ఉంచాలో --work నిర్ణయిస్తుంది. ఈ స్థానం runner directoryలో ఉంటుంది. --unattended interactive promptsకు వాటి default విలువలతో సమాధానం ఇస్తుంది. Command scriptలో ఉన్నప్పుడు ఇదే అవసరం. అదే పేరుతో ఉన్న registrationను మళ్లీ తీసుకోవాల్సి వస్తే --replace ఇప్పటికే ఉన్న registrationను స్వీకరిస్తుంది. అందువల్ల serverను rebuild చేసినప్పుడు command విఫలం కాదు.

విజయవంతమైన run ఈ linesతో ముగుస్తుంది:

√ Runner successfully added
√ Runner connection is good
√ Settings Saved.

ఇప్పుడు registration runner directoryలో .runner, .credentials మరియు .credentials_rsaparamsగా ఉంటుంది. చివరి రెండు GitHubకు ఈ runnerను గుర్తించేందుకు ఉపయోగిస్తాయి. కాబట్టి వాటిని చదవగలిగిన ఎవరైనా ఈ runnerగా impersonate చేయవచ్చు. అందుకే directory mode 700లో ఉంటుంది మరియు userకు sudo అనుమతి ఉండదు.

runnerను systemd సర్వీస్‌గా ఇన్‌స్టాల్ చేయడం

ఒక పరీక్ష కోసం టెర్మినల్‌లో ./run.sh సరిపోతుంది, కానీ మీ SSH సెషన్ ముగియగానే అది ఆగిపోతుంది. సిస్టమ్ బూట్ అయినప్పుడు runner ప్రారంభమయ్యేలా సర్వీస్‌ను ఇన్‌స్టాల్ చేయండి. VPSలో systemd సర్వీస్‌లు మరియు టైమర్‌లు యూనిట్ ఫైళ్ల గురించి వివరిస్తుంది. ఇక్కడ svc.sh మీ కోసం ఒక ఫైల్‌ను రూపొందిస్తుంది.

exit
cd /home/gharunner/actions-runner
sudo ./svc.sh install gharunner
sudo ./svc.sh start
sudo ./svc.sh status

svc.sh ఒక యూనిట్ ఫైల్‌ను /etc/systemd/system లోకి రాసి, దానిని ఎనేబుల్ చేస్తుంది కాబట్టి దీనికి root అనుమతులు అవసరం. install తర్వాత ఉండే ఆర్గ్యుమెంట్, సర్వీస్ ఏ యూజర్ పేరుతో రన్ అవ్వాలో తెలియజేస్తుంది. gharunnerని స్పష్టంగా పాస్ చేయండి. ఎటువంటి ఆర్గ్యుమెంట్ ఇవ్వకపోతే, స్క్రిప్ట్ డిఫాల్ట్‌గా $SUDO_USERని తీసుకుంటుంది, ఇది మీ అడ్మిన్ అకౌంట్. అప్పుడు ప్రతి జాబ్ sudo ఉపయోగించగల యూజర్ ద్వారా రన్ అవుతుంది.

యూనిట్ పేరు రిపోజిటరీ మరియు runner ఆధారంగా actions.runner.YOUR-USER-YOUR-REPO.vps-runner-1.service ఫార్మాట్‌లో ఉంటుంది. మీరు దానిని టైప్ చేయాల్సిన అవసరం లేదు:

systemctl list-units 'actions.runner.*'
sudo journalctl -u 'actions.runner.*' -n 20 --no-pager

సరిగ్గా పనిచేస్తున్న runner √ Connected to GitHub అని లాగ్ చేస్తుంది, ఆ తర్వాత Listening for Jobsతో ముగిసే లైన్ కనిపిస్తుంది. రిపోజిటరీ యొక్క Runners పేజీలో అది Idle అని చూపిస్తుంది. ఒకవేళ runner Offline అని కనిపిస్తే, అది రన్ అవ్వడం లేదని లేదా 443 పోర్ట్ ద్వారా GitHubని చేరుకోలేకపోతోందని అర్థం.

runner కు ఒక job ను పంపడం

runs-on ఒక runner ను label ద్వారా ఎంచుకుంటుంది. self-hosted తో పాటు మీ స్వంత label ను కూడా అడగండి, తద్వారా మీరు ఉద్దేశించని runner పై job పడకుండా ఉంటుంది.

name: build
on:
  push:
    branches: [main]
jobs:
  build:
    runs-on: [self-hosted, linux, vps]
    steps:
      - uses: actions/checkout@v5
      - run: uname -a

ఒకవేళ job Waiting for a runner to pick up this job వద్ద వేచి ఉంటే, సరిపోయే runner ఆన్‌లైన్‌లో మరియు idle లో ఉందో లేదో తనిఖీ చేయండి. runs-on లోని ప్రతి label ఆ runner పై తప్పనిసరిగా ఉండాలి, కాబట్టి ఒక అదనపు పదం ఉన్నా సరే, సరిపోయే runner అందుబాటులోకి వచ్చే వరకు లేదా 24 గంటల తర్వాత job విఫలమయ్యే వరకు అది queued లోనే ఉంటుంది. repository settings లో runner పక్కన కనిపించే labels జాబితాతో మీ జాబితాను సరిపోల్చండి.

Self-hosted runners మరియు public repositories ఎందుకు కలపకూడదు

చాలామంది విస్మరించే అంశం ఇది. GitHub మార్గదర్శకాలు చాలా స్పష్టంగా ఉన్నాయి: self-hosted runners ను "public repositories కోసం దాదాపు ఎప్పుడూ ఉపయోగించకూడదు", మరియు ఇవి "తాత్కాలికమైన, సురక్షితమైన virtual machines లో నడుస్తాయనే హామీని కలిగి ఉండవు, అలాగే workflow లోని నమ్మదగని కోడ్ ద్వారా ఇవి శాశ్వతంగా compromised అయ్యే అవకాశం ఉంది".

దీని వెనుక ఉన్న విధానం చాలా సరళమైనది. ఒక fork నుంచి వచ్చే pull request తనతో పాటు workflow ఫైల్ యొక్క కాపీని కూడా తీసుకువస్తుంది. మీ public repository లో pull request workflows మీ runner పై నడుస్తుంటే, ఎవరైనా సరే repository ని fork చేసి, వారి సొంత కమాండ్లను మీ VPS పై రన్ చేసేలా workflow ను రూపొందించవచ్చు. వారికి repository పై write access అవసరం లేదు, ఎందుకంటే వారు ప్రతిపాదించేదే ఇక్కడ రన్ అవుతుంది.

Approval సెట్టింగ్‌లు ఈ సమస్యను పూర్తిగా పరిష్కరించవు, కేవలం కొంతవరకు తగ్గిస్తాయి. Public repository కోసం డిఫాల్ట్ పాలసీ ప్రకారం, మొదటిసారి సహకారం అందించే వ్యక్తి యొక్క fork workflow ను ఆమోదించమని maintainer ను అడుగుతుంది. ఒక వ్యక్తి యొక్క commit లేదా pull request repository లో merge అయ్యే వరకు మాత్రమే GitHub వారిని 'first-time contributor' గా పరిగణిస్తుంది. ఆ తర్వాత, వారి తదుపరి pull requests ఎటువంటి అనుమతి లేకుండానే రన్ అవుతాయి. ఒక చిన్న merge అయిన fix కూడా దీనికి సరిపోతుందని GitHub స్వయంగా హెచ్చరిస్తుంది. కాబట్టి, ఇక్కడ రక్షణ అనేది ఒక మనిషి diff ను చదవడంపై ఆధారపడి ఉంటుంది, కానీ build script లో మూడు స్థాయిల లోతులో దాగి ఉన్న payload ను గుర్తించడం చాలా కష్టం.

Fork pull request కు మీ secrets అందవు, మరియు దాని GITHUB_TOKEN కేవలం read-only గా ఉంటుంది. ఇది GitHub లోపల జరిగే నష్టాన్ని పరిమితం చేస్తుంది. కానీ ఇది మీ సర్వర్‌కు ఎటువంటి రక్షణ ఇవ్వదు. దాడి చేసే వ్యక్తికి gharunner గా shell లభిస్తుంది, కాబట్టి ఆ user చదవగలిగే ప్రతి ఫైల్‌ను వారు చూడగలరు, VPS తన private network లో చేరుకోగల దేనినైనా యాక్సెస్ చేయగలరు, మరియు తదుపరి job రన్ అయ్యేటప్పుడు పనిచేసేలా ~/.bashrc లో లేదా user systemd unit లో ఏదైనా హానికరమైన కోడ్‌ను వదిలి వెళ్లగలరు.

--ephemeral తో register చేయడం వల్ల runner ఒక job ను పూర్తి చేసి deregister అవుతుంది; కానీ అది ఆ job యొక్క workspace ను తుడిచిపెట్టదు. ప్రతి job కోసం machine లేదా container ను మళ్ళీ మొదటి నుంచి నిర్మిస్తేనే ఇది ఉపయోగపడుతుంది, ఎందుకంటే runner user యొక్క home directory లో రాసిన backdoor కొత్త registration తర్వాత కూడా అలాగే ఉంటుంది.

తదుపరి నియమాలు చాలా చిన్నవి. Self-hosted runners ను కేవలం private repositories కోసం మాత్రమే ఉపయోగించండి. ఒకవేళ తప్పనిసరిగా public repository కి అనుసంధానించాల్సి వస్తే, దానిపై fork pull requests ను రన్ చేయకండి, ఆ సర్వర్‌పై మరే ఇతర సేవలను ఉంచకండి, మరియు ఆ machine ను ఎప్పుడైనా పారేయదగినదిగా (disposable) పరిగణించండి.

Docker జాబ్‌లు మరియు నిజమైన root గ్రూప్

Container జాబ్‌లు, service containerలు మరియు docker buildని పిలిచే ఏదైనా workflow స్టెప్‌కు runner హోస్ట్‌పై Docker daemon అవసరం. Dockerను సాధారణ పద్ధతిలో ఇన్‌స్టాల్ చేయండి, దీని గురించి Docker and Docker Compose on a VPSలో వివరించబడింది, ఆపై runner యూజర్‌ను docker గ్రూప్‌కు జోడించండి.

దీనిని చేసే ముందు దీనివల్ల కలిగే పరిణామాలను అర్థం చేసుకోండి. docker గ్రూప్‌లో సభ్యత్వం కలిగి ఉండటం అనేది root హోదాకు సమానం, ఎందుకంటే ఒక container /ని bind mount చేసి దాని లోపల rootగా రన్ అవ్వగలదు. కాబట్టి Docker socketతో కమ్యూనికేట్ చేయగల workflow, /etc/shadowతో సహా VPSలోని ప్రతి ఫైల్‌ను చదవగలదు మరియు రాయగలదు. నమ్మకమైన contributors ఉన్న ప్రైవేట్ రిపోజిటరీలో ఇది ఆమోదయోగ్యమైనదే కావచ్చు. ఇతర చోట్ల ఇది unprivileged యూజర్ ఉద్దేశ్యాన్ని దెబ్బతీస్తుంది. Rootless Docker, కంటైనర్ బిల్డ్‌లను runner యూజర్ యొక్క స్వంత హక్కుల పరిధిలోనే ఉంచుతుంది, అయితే దీనికి storage driver మరియు నెట్‌వర్కింగ్ పరిమితులు ఉంటాయి; కంటైనర్ సామర్థ్యాలు హోస్ట్‌పై ఎటువంటి అదనపు అధికారాలను ఇవ్వవు.

అప్‌డేట్‌లు మరియు రన్నర్‌ను సురక్షితంగా తొలగించడం

సెల్ఫ్-హోస్టెడ్ రన్నర్ డిఫాల్ట్‌గా తనను తాను అప్‌డేట్ చేసుకుంటుంది. ఇది కొత్త release వచ్చినప్పుడు గుర్తించి, తన ఫైళ్లను తానే మార్చుకుని, సర్వీస్‌ను రీస్టార్ట్ చేస్తుంది, కాబట్టి సాధారణంగా మీరు ఏమీ చేయనవసరం లేదు. సెల్ఫ్-అప్‌డేట్‌ను ఆపివేయడానికి, మీరు రన్నర్‌ను రిజిస్టర్ చేసేటప్పుడు --disableupdate ను ./config.sh కి పాస్ చేయండి; ఇప్పటికే రిజిస్టర్ చేసిన రన్నర్ విషయంలో, ఆ ఫ్లాగ్‌తో మళ్లీ రిజిస్టర్ చేయాల్సి ఉంటుంది. అయితే, ఇది మిమ్మల్ని శాశ్వతంగా ఒకే వెర్షన్‌లో ఉండనివ్వదు. --disableupdate తో కాన్ఫిగర్ చేసిన రన్నర్‌ను కూడా కొత్త release వచ్చిన 30 రోజులలోపు మాన్యువల్‌గా అప్‌డేట్ చేయాలని, లేకపోతే GitHub దానికి జాబ్‌లను క్యూ చేయడం ఆపివేస్తుందని GitHub డాక్యుమెంటేషన్ స్పష్టంగా పేర్కొంది. ఏదైనా కీలకమైన సెక్యూరిటీ అప్‌డేట్ వచ్చినప్పుడు, ఆ గడువు కోసం వేచి చూడకుండానే, మీరు అప్‌డేట్ చేసే వరకు జాబ్‌లు క్యూ కాకుండా ఆగిపోవచ్చు.

మాన్యువల్ అప్‌డేట్ చేసినప్పుడు రిజిస్ట్రేషన్ అలాగే ఉంటుంది, ఎందుకంటే .runner మరియు .credentials అనేవి tarball లో ఉండవు. సర్వీస్‌ను ఆపివేసి, కొత్త tarball ను gharunner గా డౌన్‌లోడ్ చేసి checksum సరిచూసుకోండి, ఆపై tar xzf తో అదే డైరెక్టరీలో extract చేసి, సర్వీస్‌ను మళ్లీ ప్రారంభించండి:

cd /home/gharunner/actions-runner
sudo ./svc.sh stop
sudo ./svc.sh start

రన్నర్‌ను తొలగించడానికి, ముందుగా సర్వీస్‌ను అన్‌ఇన్‌స్టాల్ చేసి, ఆపై డీరిజిస్టర్ చేయండి. రిమూవల్ టోకెన్ అదే Runners పేజీలో, రన్నర్ యొక్క స్వంత Remove బటన్ కింద లభిస్తుంది.

cd /home/gharunner/actions-runner
sudo ./svc.sh stop
sudo ./svc.sh uninstall
sudo -iu gharunner
cd ~/actions-runner
./config.sh remove --token PASTE_REMOVAL_TOKEN_HERE

డీరిజిస్టర్ చేయకుండా డైరెక్టరీని డిలీట్ చేస్తే, రన్నర్ రిపోజిటరీలో Offline అని కనిపిస్తుంది. అడ్మిన్ ఎవరైనా Force remove this runner అని క్లిక్ చేసే వరకు లేదా 14 రోజుల పాటు కనెక్షన్ లేకపోతే GitHub స్వయంచాలకంగా తొలగించే వరకు అది అక్కడే ఉంటుంది.

మీరు చూడబోయే సందేశాలతో వైఫల్య పరిస్థితులు

Must not run with sudo. root గా దీన్ని నడిపినప్పుడు config.sh ఈ సందేశాన్ని చూపించి నిష్క్రమిస్తుంది. ఈ తనిఖీ ఉద్దేశపూర్వకంగా ఉంటుంది. _work లో root యాజమాన్యంలోని ఫైళ్లు ఉంటే, service user గా నడిచే తరువాతి ప్రతి job విఫలమవుతుంది. ./config.sh ను gharunner గా నడపండి. RUNNER_ALLOW_RUNASROOT variable ఈ తనిఖీని override చేస్తుంది. అయితే దీన్ని ఉపయోగిస్తే వైఫల్యం తరువాతి దశకు మాత్రమే వాయిదా పడుతుంది.

sudo: ./svc.sh: command not found. మీరు సరైన directory లో ఉన్నారు. svc.sh ఇంకా లేదు. ఎందుకంటే config.sh registration పూర్తి చేయలేదు. Runner ను register చేసి, తరువాత service ను install చేయండి.

Http response code: NotFound from 'POST https://api.github.com/actions/runner-registration'. సాధారణంగా token చెల్లుబాటు అయ్యే registration token కాదు. చివరి token ఒక గంట మాత్రమే చెల్లుతుంది కాబట్టి అది expire అయి ఉండవచ్చు. లేదా Runners page లోని registration token స్థానంలో personal access token ను paste చేసి ఉండవచ్చు. కొత్త token ను generate చేసి మళ్లీ paste చేయండి. --url పూర్తి repository URL అని నిర్ధారించండి.

Dependencies is missing for Dotnet Core 6.0. Runner directory నుంచి root గా sudo ./bin/installdependencies.sh ను నడిపి, తరువాత మళ్లీ register చేయండి.

Reboot తర్వాత Runner Offline. systemctl is-enabled 'actions.runner.*' ను నడపండి. ఏదీ కనిపించకపోతే ./svc.sh install ఎప్పుడూ నడపలేదు. అందువల్ల runner మీ terminal session లో మాత్రమే ఉండేది. Unit enabled గా ఉండి, runner ఇంకా Offline గా ఉంటే journalctl -u 'actions.runner.*' ను చదివి outbound HTTPS ను తనిఖీ చేయండి.

డిస్క్ నిండిపోతుంది. Checkouts, build caches, Docker images _work కింద మరియు runner user home లో పేరుకుపోతాయి. వాటిని స్వయంచాలకంగా తొలగించే ప్రక్రియ ఉండదు. du -sh /home/gharunner/actions-runner/_work ను monitor చేసి, డిస్క్ పూర్తిగా నిండకముందే scheduled clean-up ను జోడించండి.

FAQ

sudo ./svc.sh installలో command not found అని ఎందుకు చూపుతుంది?

svc.sh runner tarballలో లేదు. ./config.sh registration పూర్తి చేసినప్పుడు, మీ repository మరియు runner పేర్లను ఉపయోగించి service nameను రూపొందిస్తూ ఇది runner directoryలో సృష్టించబడుతుంది. ముందుగా runner userగా ./config.sh ను అమలు చేయండి. ఆ తర్వాత sudo ./svc.sh install gharunner scriptను కనుగొని, /etc/systemd/systemలో actions.runner.OWNER-REPO.RUNNER-NAME.service పేరుతో unitను రాస్తుంది.

self-hosted runner కోసం firewall portను తెరవాలా?

అవసరం లేదు. Jobs కోసం వేచి ఉన్నప్పుడు runner GitHubకు outbound HTTPS connectionను తెరిచి ఉంచుతుంది. అందువల్ల GitHub మీ VPSకు connectionను ప్రారంభించదు. Outbound 443ను అనుమతించి, inbound rulesను మూసి ఉంచండి. Service నడుస్తున్నప్పటికీ runner Offlineగా చూపిస్తే, inbound rulesకు బదులుగా outbound filtering మరియు DNSను పరిశీలించండి.

public repositoryలో self-hosted runnerను ఉపయోగించవచ్చా?

ఉపయోగించవచ్చు. అయితే GitHub దీన్ని సిఫార్సు చేయదు. Fork నుంచి వచ్చే pull requestలో ఆ forkకు చెందిన workflow file ఉంటుంది. అందువల్ల మీ repositoryను fork చేయగల ఎవరైనా మీ machineపై అమలయ్యే commandsను ప్రతిపాదించవచ్చు. Default approval prompt, repositoryలో ఇంతకు ముందు commit లేదా pull request merge కాని contributorsకే వర్తిస్తుంది. Public repositoryకి runnerను అనుసంధానిస్తే, దానిపై fork pull request workflowsను disable చేయండి. ఆ serverలో మరే ఇతరదీ ఉంచవద్దు. నిర్ణయించిన వ్యవధిలో machineను మళ్లీ build చేయండి.

Http response code: NotFoundతో registration ఎందుకు విఫలమవుతుంది?

Credential తప్పుగా ఉన్నప్పుడు కూడా registration call NotFoundను తిరిగి ఇస్తుంది. URL తప్పుగా ఉన్నప్పుడు మాత్రమే ఇది జరుగదు. అందువల్ల ఈ message తప్పుదారి పట్టించవచ్చు. Registration tokens చూపించిన ఒక గంట తర్వాత expire అవుతాయి. ఈ callకు personal access token ఆమోదించబడదు. మళ్లీ Settings, Actions, Runners, New self-hosted runnerను తెరిచి, కొత్త tokenను copy చేయండి. --url విలువ మీకు admin rights ఉన్న repository వైపు చూపుతోందని నిర్ధారించండి.

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

#github-actions#ci#self-hosted#runner#ubuntu-24-04