Ubuntu 24.04లో సెల్ఫ్-హోస్టెడ్ GitHub Actions రన్నర్ సెటప్

సెల్ఫ్-హోస్టెడ్ GitHub Actions రన్నర్ అంటే ఏమిటి

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

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

కింద ఉన్న సమాచారం అంతా Ubuntu 24.04 మరియు రన్నర్ వెర్షన్ 2.336.0 కోసం. ఇది జూలై 2026 నాటికి అందుబాటులో ఉన్న తాజా రిలీజ్.

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

సాధారణ అడ్మిన్ ఖాతా మరియు 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 యూజర్‌గా పని చేయండి.

sudo -iu gharunner
cd ~/actions-runner
RUNNER_VERSION=2.336.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"

మీకు ఆర్కిటెక్చర్ గురించి ఖచ్చితంగా తెలియకపోతే ముందుగా uname -m రన్ చేయండి. x86_64 పైన పేర్కొన్న linux-x64 ఫైల్‌ను తీసుకుంటుంది. aarch64 అనేది actions-runner-linux-arm64-${RUNNER_VERSION}.tar.gzని తీసుకుంటుంది.

ఇప్పుడు మీరు డౌన్‌లోడ్ చేసిన దానిని ధృవీకరించండి. దిగువన ఉన్న SHA256 (secure hash algorithm, 256 bit) విలువ 2.336.0 x64 టార్‌బాల్ కోసం ఉద్దేశించబడింది. GitHub ప్రస్తుత విడుదల కోసం విలువను విడుదల పేజీలో మరియు New self-hosted runner స్క్రీన్‌పై ప్రదర్శిస్తుంది. ఇది ప్రతి వెర్షన్‌తో మారుతుంది, కాబట్టి మీరు వేరే వెర్షన్‌ను ఇన్‌స్టాల్ చేస్తున్నప్పుడు దాని నుండి కాపీ చేయండి.

echo "04cf0be1aff4c3ec3554466c39124ca250e3effd8873bb7e8d68535aa9505d5d  actions-runner-linux-x64-2.336.0.tar.gz" | sha256sum -c

సరైన డౌన్‌లోడ్ అయితే ఒక లైన్‌ను ప్రింట్ చేస్తుంది:

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

అసంపూర్ణంగా ఉన్న లేదా మార్చబడిన ఫైల్ వైఫల్యాన్ని మరియు హెచ్చరికను ప్రింట్ చేస్తుంది:

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

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

tar xzf ./actions-runner-linux-x64-2.336.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 తో విఫలమవుతుంది. ముందుగా రిజిస్టర్ చేయండి, ఆ తర్వాత సర్వీస్‌ను ఇన్‌స్టాల్ చేయండి.

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

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

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

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

ఈ దశను దాటవేస్తే, ./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 ప్రారంభానికి ముందు బండిల్ చేయబడిన లైబ్రరీలపై lddని రన్ చేస్తుంది, కాబట్టి ఏదైనా లింక్ రిజాల్వ్ కాకపోతే, తర్వాత గందరగోళంగా క్రాష్ అవ్వడానికి బదులుగా స్క్రిప్ట్ అక్కడే ఆగిపోతుంది.

మీ రిపోజిటరీతో రన్నర్‌ను రిజిస్టర్ చేయండి

రిపోజిటరీ నుండి ఒక టోకెన్‌ను పొందండి. Settings, ఆపై Actions, ఆపై Runners, ఆపై New self-hosted runner ఓపెన్ చేయండి. ఆ పేజీ A తో ప్రారంభమయ్యే రిజిస్ట్రేషన్ టోకెన్‌ను చూపుతుంది. ఇది సృష్టించబడిన ఒక గంట తర్వాత గడువు ముగుస్తుంది, కాబట్టి మీరు దాన్ని పేస్ట్ చేయడానికి సిద్ధంగా ఉన్నప్పుడు మాత్రమే దాన్ని రూపొందించండి.

రన్నర్ యూజర్‌గా రిజిస్టర్ చేయండి. config.sh ను sudo కింద రన్ చేయడానికి అనుమతించబడదు.

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

ఆ ఫ్లాగ్‌లు ఏమి చేస్తాయో ఇక్కడ ఉంది. --name అనేది రిపోజిటరీలో రన్నర్ కనిపించే పేరు, కాబట్టి ఆరు నెలల తర్వాత కూడా మీకు గుర్తుండే పేరును ఎంచుకోండి. --labels మీ స్వంత లేబుల్‌లను జోడిస్తుంది; రన్నర్ ఇప్పటికే అడగకుండానే self-hosted, Linux మరియు X64 లేబుల్‌లను కలిగి ఉంటుంది. --work అనేది రన్నర్ డైరెక్టరీ లోపల, చెకౌట్‌లు జరిగే డైరెక్టరీకి పేరు పెడుతుంది. --unattended ఇంటరాక్టివ్ ప్రాంప్ట్‌లకు వాటి డిఫాల్ట్ విలువలతో సమాధానమిస్తుంది, కమాండ్ స్క్రిప్ట్‌లో ఉన్నప్పుడు మీకు ఇదే కావాలి. --replace అదే పేరుతో ఉన్న ఇప్పటికే ఉన్న రిజిస్ట్రేషన్‌ను భర్తీ చేస్తుంది, ఇది ఫెయిల్ అవ్వకుండా ఉండటానికి సహాయపడుతుంది; మీరు సర్వర్‌ను రీబిల్డ్ చేస్తున్నప్పుడు ఇది అవసరం.

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

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

రిజిస్ట్రేషన్ ఇప్పుడు రన్నర్ డైరెక్టరీలో .runner, .credentials మరియు .credentials_rsaparams ఫైల్స్‌గా ఉంటుంది. చివరి రెండు ఫైల్స్ ఈ రన్నర్‌ను GitHub కి గుర్తిస్తాయి, కాబట్టి వాటిని చదవగలిగే ఎవరైనా దీనిని అనుకరించగలరు. అందుకే డైరెక్టరీ మోడ్ 700 లో ఉంటుంది మరియు యూజర్‌కు 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ని చేరుకోలేకపోతోందని అర్థం.

రన్నర్‌కు జాబ్‌ను పంపడం

runs-on లేబుల్ ద్వారా రన్నర్‌ను ఎంచుకుంటుంది. self-hosted మరియు మీ స్వంత లేబుల్‌ను అడగండి, తద్వారా మీరు ఉద్దేశించని రన్నర్‌పై జాబ్ పడదు.

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

ఒకవేళ జాబ్ Waiting for a runner to pick up this job వద్ద వేచి ఉంటే, లేబుల్స్ సరిపోలడం లేదని అర్థం. runs-on లోని ప్రతి లేబుల్ రన్నర్‌పై తప్పనిసరిగా ఉండాలి, కాబట్టి ఒక అదనపు పదం ఉన్నా సరే జాబ్ క్యూలోనే ఉండిపోతుంది మరియు ఎక్కడా ఎర్రర్ చూపదు. రిపోజిటరీ సెట్టింగ్‌లలో రన్నర్ పక్కన కనిపించే లేబుల్స్ జాబితాతో దీన్ని సరిపోల్చండి.

సెల్ఫ్-హోస్టెడ్ రన్నర్లు మరియు పబ్లిక్ రిపోజిటరీలను ఎందుకు కలపకూడదు

చాలామంది విస్మరించే అంశం ఇది. GitHub మార్గదర్శకాలు చాలా స్పష్టంగా ఉన్నాయి: సెల్ఫ్-హోస్టెడ్ రన్నర్లను "పబ్లిక్ రిపోజిటరీల కోసం దాదాపు ఎప్పుడూ ఉపయోగించకూడదు", మరియు ఇవి "తాత్కాలికమైన, శుభ్రమైన వర్చువల్ మెషీన్లలో నడుస్తాయనే హామీని కలిగి ఉండవు, అలాగే వర్క్‌ఫ్లోలోని నమ్మదగని కోడ్ ద్వారా ఇవి శాశ్వతంగా రాజీ పడే (compromised) అవకాశం ఉంది".

దీని వెనుక ఉన్న విధానం చాలా సరళమైనది. ఒక ఫోర్క్ (fork) నుండి వచ్చే పుల్ రిక్వెస్ట్ తన సొంత వర్క్‌ఫ్లో ఫైల్ కాపీని తీసుకువస్తుంది. మీ పబ్లిక్ రిపోజిటరీ మీ రన్నర్‌పై పుల్ రిక్వెస్ట్ వర్క్‌ఫ్లోలను రన్ చేస్తే, రిపోజిటరీని ఫోర్క్ చేయగల ఎవరైనా సరే, మీ VPSపై వారి కమాండ్లను రన్ చేసే వర్క్‌ఫ్లోను ప్రతిపాదించవచ్చు. వారికి రైట్ యాక్సెస్ (write access) అవసరం లేదు, ఎందుకంటే వారు ప్రతిపాదిస్తున్న అంశమే రన్ అయ్యేదిగా ఉంటుంది.

అప్రూవల్ సెట్టింగ్‌లు ఈ సమస్యను పూర్తిగా పరిష్కరించవు, కానీ కొంతవరకు తగ్గిస్తాయి. పబ్లిక్ రిపోజిటరీ కోసం డిఫాల్ట్ పాలసీ ప్రకారం, మొదటిసారి కాంట్రిబ్యూట్ చేసే వ్యక్తి యొక్క ఫోర్క్ వర్క్‌ఫ్లోను ఆమోదించమని మెయింటైనర్‌ను అడుగుతుంది. మీరు ఒకసారి ఆ వ్యక్తిని ఆమోదించిన తర్వాత, వారి తదుపరి పుల్ రిక్వెస్ట్‌లు కొత్త ప్రాంప్ట్ లేకుండానే రన్ అవుతాయి. కాబట్టి, ప్రతిసారీ ఒక మనిషి డిఫ్ (diff)ను పరిశీలించాల్సి ఉంటుంది, కానీ బిల్డ్ స్క్రిప్ట్‌లో మూడు స్థాయిల లోతులో దాగి ఉన్న పేలోడ్‌ను గుర్తించడం సులభం కాదు.

ఫోర్క్ పుల్ రిక్వెస్ట్‌కు మీ సీక్రెట్స్ అందవు మరియు దాని GITHUB_TOKEN రీడ్-ఓన్లీగా ఉంటుంది. ఇది GitHub లోపల జరిగే నష్టాన్ని పరిమితం చేస్తుంది. కానీ ఇది మీ సర్వర్‌కు ఏమీ చేయలేదు. దాడి చేసే వ్యక్తికి gharunnerగా షెల్ లభిస్తుంది, కాబట్టి ఆ యూజర్ చదవగలిగే ప్రతి ఫైల్‌ను వారు చదవగలరు, ఆ VPS తన ప్రైవేట్ నెట్‌వర్క్‌లో చేరుకోగల దేనినైనా యాక్సెస్ చేయగలరు, మరియు ~/.bashrcలో లేదా తదుపరి జాబ్ సమయంలో రన్ అయ్యే యూజర్ systemd యూనిట్‌లో ఏదైనా హానికరమైన కోడ్‌ను వదిలివేయగలరు.

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

కింద ఉన్న నియమాలు చాలా చిన్నవి. సెల్ఫ్-హోస్టెడ్ రన్నర్లను ప్రైవేట్ రిపోజిటరీల కోసం మాత్రమే ఉపయోగించండి. ఒకవేళ మీరు పబ్లిక్ రిపోజిటరీకి వీటిని తప్పనిసరిగా అనుసంధానించాల్సి వస్తే, దానిపై ఫోర్క్ పుల్ రిక్వెస్ట్‌లను రన్ చేయకండి, ఆ సర్వర్‌పై మరే ఇతర డేటాను ఉంచకండి, మరియు ఆ మెషీన్‌ను ఎప్పుడైనా పారేయదగినదిగా (disposable) పరిగణించండి.

Docker జాబ్‌లు మరియు నిజానికి rootగా ఉండే గ్రూప్

కంటైనర్ జాబ్‌లు, సర్వీస్ కంటైనర్లు మరియు docker buildని పిలిచే ఏదైనా వర్క్‌ఫ్లో స్టెప్‌కు రన్నర్ హోస్ట్‌లో Docker డెమోన్ అవసరం. VPSపై Docker మరియు Docker Composeలో వివరించిన విధంగా Dockerను ఇన్‌స్టాల్ చేయండి, ఆపై రన్నర్ యూజర్‌ను docker గ్రూప్‌కు జోడించండి.

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

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

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

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

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 అని కనిపిస్తుంది. ఎందుకంటే రన్నర్ స్వయంగా చెప్పినప్పుడు లేదా అడ్మిన్ మాన్యువల్‌గా ఎంట్రీని తొలగించినప్పుడు మాత్రమే అది తొలగిపోయినట్లు GitHubకు తెలుస్తుంది.

వైఫల్య రీతులు, మీరు చూసే స్ట్రింగ్‌లతో

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

sudo: ./svc.sh: command not found. మీరు సరైన డైరెక్టరీలోనే ఉన్నారు. svc.sh ఇంకా ఉనికిలో లేదు, ఎందుకంటే config.sh రిజిస్ట్రేషన్‌ను పూర్తి చేయలేదు. రన్నర్‌ను రిజిస్టర్ చేయండి, ఆపై సర్వీస్‌ను ఇన్‌స్టాల్ చేయండి.

Http response code: NotFound from 'POST https://api.github.com/actions/runner-registration'. ఈ టోకెన్ చెల్లుబాటు అయ్యే రిజిస్ట్రేషన్ టోకెన్ కాదు. ఇవి ఒక గంట మాత్రమే ఉంటాయి కాబట్టి ఇది గడువు ముగిసి ఉండవచ్చు, లేదా Runners పేజీ నుండి వచ్చిన రిజిస్ట్రేషన్ టోకెన్‌కు బదులుగా పర్సనల్ యాక్సెస్ టోకెన్‌ను పేస్ట్ చేసి ఉండవచ్చు. కొత్త టోకెన్‌ను జనరేట్ చేసి మళ్లీ పేస్ట్ చేయండి.

Dependencies is missing for Dotnet Core 6.0. sudo ./bin/installdependencies.shని రన్నర్ డైరెక్టరీ నుండి rootగా రన్ చేయండి, ఆపై మళ్లీ రిజిస్టర్ చేయండి.

రీబూట్ తర్వాత రన్నర్ ఆఫ్‌లైన్. systemctl is-enabled 'actions.runner.*'ని రన్ చేయండి. ఏమీ జాబితా చేయబడకపోతే, ./svc.sh install ఎప్పుడూ రన్ చేయబడలేదు, కాబట్టి రన్నర్ మీ టెర్మినల్ సెషన్‌లో మాత్రమే ఉనికిలో ఉంది. యూనిట్ ఎనేబుల్ చేయబడి ఉండి, రన్నర్ ఇంకా ఆఫ్‌లైన్‌లోనే ఉంటే, journalctl -u 'actions.runner.*'ని చదవండి మరియు అవుట్‌బౌండ్ HTTPSని తనిఖీ చేయండి.

డిస్క్ నిండిపోవడం. చెకౌట్‌లు, బిల్డ్ కాష్‌లు మరియు Docker ఇమేజ్‌లు _work కింద మరియు రన్నర్ యూజర్ హోమ్ డైరెక్టరీలో పేరుకుపోతాయి, వీటిని క్లీన్ చేయడానికి ఏదీ లేదు. du -sh /home/gharunner/actions-runner/_workని మానిటర్ చేయండి మరియు డిస్క్ నిండిపోకముందే షెడ్యూల్ చేసిన క్లీన్-అప్‌ను జోడించండి.

FAQ

sudo ./svc.sh install కమాండ్ దొరకలేదని ఎందుకు చూపిస్తుంది?

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

సెల్ఫ్-హోస్టెడ్ రన్నర్ కోసం ఫైర్‌వాల్ పోర్ట్‌ను ఓపెన్ చేయాలా?

అవసరం లేదు. రన్నర్ GitHubకి అవుట్‌బౌండ్ HTTPS కనెక్షన్‌ను ఓపెన్ చేసి, జాబ్స్ కోసం వేచి ఉన్నప్పుడు దానిని అలాగే ఉంచుతుంది, కాబట్టి GitHub మీ VPSకి ఎప్పుడూ కనెక్షన్‌ను ప్రారంభించదు. అవుట్‌బౌండ్ 443ని అనుమతించండి మరియు మీ ఇన్‌బౌండ్ రూల్స్‌ను క్లోజ్ చేసి ఉంచండి. సర్వీస్ రన్ అవుతున్నప్పుడు రన్నర్ Offline అని చూపిస్తే, ఇన్‌బౌండ్ రూల్స్ కాకుండా అవుట్‌బౌండ్ ఫిల్టరింగ్ మరియు DNSని తనిఖీ చేయండి.

పబ్లిక్ రిపోజిటరీలో నేను సెల్ఫ్-హోస్టెడ్ రన్నర్‌ని ఉపయోగించవచ్చా?

మీరు ఉపయోగించవచ్చు, కానీ GitHub దీనిని సిఫార్సు చేయదు. ఫోర్క్ నుండి వచ్చే పుల్ రిక్వెస్ట్ దాని స్వంత వర్క్‌ఫ్లో ఫైల్‌ను కలిగి ఉంటుంది, కాబట్టి మీ రిపోజిటరీని ఫోర్క్ చేయగల ఎవరైనా మీ మెషీన్‌లో రన్ అయ్యే కమాండ్లను ప్రతిపాదించగలరు. అప్రూవల్ ప్రాంప్ట్ కేవలం కంట్రిబ్యూటర్ యొక్క మొదటి రన్‌కు మాత్రమే వర్తిస్తుంది. మీరు పబ్లిక్ రిపోజిటరీకి రన్నర్‌ని జోడిస్తే, దానిపై ఫోర్క్ పుల్ రిక్వెస్ట్ వర్క్‌ఫ్లోలను డిసేబుల్ చేయండి, ఆ సర్వర్‌లో మరేమీ ఉంచకండి మరియు నిర్ణీత సమయాల్లో మెషీన్‌ను రీబిల్డ్ చేయండి.

Http response code: NotFoundతో రిజిస్ట్రేషన్ ఎందుకు విఫలమవుతుంది?

URL తప్పుగా ఉన్నప్పుడు మాత్రమే కాకుండా, క్రెడెన్షియల్ తప్పుగా ఉన్నప్పుడు కూడా రిజిస్ట్రేషన్ కాల్ NotFound అని సమాధానం ఇస్తుంది, ఇది సందేశాన్ని తప్పుదారి పట్టించేలా చేస్తుంది. రిజిస్ట్రేషన్ టోకెన్లు చూపబడిన ఒక గంట తర్వాత ఎక్స్‌పైర్ అవుతాయి మరియు ఈ కాల్ కోసం పర్సనల్ యాక్సెస్ టోకెన్ ఆమోదించబడదు. Settings, Actions, Runners, New self-hosted runnerని మళ్ళీ ఓపెన్ చేయండి, కొత్త టోకెన్‌ను కాపీ చేయండి మరియు --url విలువ మీకు అడ్మిన్ హక్కులు ఉన్న రిపోజిటరీని సూచిస్తుందో లేదో నిర్ధారించుకోండి.