SSD Nodes Learn Hosting plans →

VPSలో single-node k3s ఎప్పుడు ఉపయోగకరం?

k3s ఒక VPSలో నిజమైన Kubernetes API ఇస్తుంది. ఎంత RAM పడుతుంది, install సమయంలో port 80 ఎందుకు ఢీకొంటుంది, Docker Compose ఎప్పుడు మంచిదో తెలుసుకోండి.

k3s అంటే ఏమిటి, దాని ఒక node మీకు ఏమి అందిస్తుంది

k3s అనేది ఒకే binaryగా ప్యాకేజ్ చేసిన పూర్తి Kubernetes distribution. దీన్ని ఒకే VPSపై నడిపితే, మూడు యంత్రాల control plane లేకుండానే నిజమైన Kubernetes API లభిస్తుంది. ఇది certified Kubernetes distribution. అందువల్ల ఇక్కడ apply చేసే manifest‌ను తరువాత managed cluster‌లో కూడా apply చేయవచ్చు. Installation ఒక command‌తో పూర్తవుతుంది మరియు సుమారు ఒక నిమిషం పడుతుంది. దీనికి మీరు చెల్లించేది, మీ applications‌కు ఇక అందుబాటులో లేని memoryతో పాటు, Docker Compose‌లో ఎప్పుడూ ఎదురుకాని కొన్ని failure modes.

SUSE edge sites మరియు చిన్న installations కోసం k3s‌ను రూపొందిస్తుంది. Upstream Kubernetes‌తో పోలిస్తే దీని మార్పులు, దీన్ని చిన్నదిగా మరియు నిర్వహణకు సరళంగా చేయడానికే ఉన్నాయి. Default datastoreగా etcdకు బదులుగా kine అనే shim వెనుక sqlite ఉపయోగించబడుతుంది. అందువల్ల నిర్వహించాల్సిన etcd quorum ఉండదు. containerd‌ను విడిగా install చేయకుండా binaryలోనే పొందుపరిచారు. Cluster DNS కోసం CoreDNS, ingress controllerగా Traefik, cloud provider లేకుండానే LoadBalancer services పనిచేయడానికి ServiceLB (దీనిని klipper-lb అని కూడా అంటారు), persistent volumes కోసం local-path provisioner, metrics-server, pod networking కోసం flannel కూడా అదే binaryతో వస్తాయి. ఇవన్నీ default‌గా ప్రారంభమవుతాయి. ఈ defaults వల్ల Traefik ports 80 మరియు 443పై listening చేస్తుంది. కాబట్టి ఇప్పటికే ఏదైనా service అందిస్తున్న VPSలో install చేయడానికి ముందు ఆ ports‌ను ఎవరు ఉపయోగించాలో నిర్ణయించండి.

ఒకే k3s node ఎప్పుడు సముచితంగా ఉంటుంది

ఈ నియమాన్ని అనుసరించండి. మీకు కావలసింది Kubernetes API అయితే k3s ను ఉపయోగించండి: మీరు నియంత్రించే machine పై Kubernetes నేర్చుకుంటున్నప్పుడు, లేదా మీకు కావలసిన software Helm chart మాత్రమే publish చేస్తున్నప్పుడు ఇది సరైన ఎంపిక. Manifest portability కూడా ప్రయోజనకరమే, ఎందుకంటే ఇక్కడ మీరు రాసిన Deployment ను ఎలాంటి మార్పులు లేకుండా managed cluster కు తరలించవచ్చు. మీకు కావలసింది applications అయితే Docker Compose ను ఉపయోగించండి. Compose చాలా తక్కువ భాగాలతో అదే containers ను ప్రారంభిస్తుంది. ఒక సంవత్సరం తరువాత కూడా VPS పై ఉన్న Compose file manifests ఉన్న directory కంటే సులభంగా చదవగలిగేది.

ఒక node ఏమి అందించదో స్పష్టంగా తెలుసుకోండి.

  • High availability ఉండదు. VPS reboot అయితే ప్రతి workload ఆగిపోతుంది. Kubernetes ఒక pod ను మరొక node పై reschedule చేస్తుంది. ఇక్కడ మరొక node ఉండదు.
  • ఒక machine పై రెండు replicas ను application నిర్వహించగలిగితే, వాటికి node లో తగినంత వనరులు ఉంటే తప్ప, service కొనసాగుతూనే ఉండే rolling update ఉండదు.
  • దిగువన ఉన్న local-path section లో వివరించిన కారణంతో storage ఆ machine కే పరిమితం అవుతుంది.
  • మీరు ఏదైనా deploy చేసినా చేయకపోయినా సుమారు ఒక gigabyte RAM ఉపయోగించే control plane ఉంటుంది.

దీంతో k3s చెడు ఎంపిక అవుతుందని కాదు. సాధారణంగా ప్రజలు చెప్పే reliability కారణం కోసం అది చెడు ఎంపిక అవుతుంది. మీరు నిజంగా అనేక machines కలిగిన multi-node cluster నిర్మించాలనుకుంటే, ముందుగా ఆ నిర్ణయం తీసుకోవాలి: k3s వాటిపై ఏమి నడుస్తుందో నిర్ణయించే ముందు, మీ స్వంత hardware పై Proxmox లేదా rented VPS nodes ఎక్కడి నుంచి వస్తాయో నిర్ణయిస్తుంది.

మీరు ఏదీ deploy చేయకముందు k3s వినియోగించే RAM మరియు CPU

k3s ప్రాజెక్ట్ అంచనాల బదులుగా కొలిచిన గణాంకాలను ప్రచురిస్తుంది. వాటిని జాగ్రత్తగా చదవండి, ఎందుకంటే సాధారణంగా చెప్పే సంఖ్య idle k3s వినియోగాన్ని సూచించదు.

చార్ట్Published k3s resource use, 95th percentile, Intel 8375C, k3s v1.26.5
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
  {
    "label": "Server, sqlite datastore",
    "ram_mb": "1,596",
    "cpu_percent_of_one_core": 6
  },
  {
    "label": "Server, embedded etcd",
    "ram_mb": "1,606",
    "cpu_percent_of_one_core": 6
  },
  {
    "label": "Agent node only",
    "ram_mb": "275",
    "cpu_percent_of_one_core": 3
  }
]

ఆ పరీక్షలో server node 95వ percentile వద్ద 1,596 MB RAM మరియు ఒక core లో సుమారు 6 శాతం CPU వినియోగించింది. ఇవి ప్రచురించిన గణాంకాలు; ఈ guide నుంచి తీసుకున్న కొలతలు కావు. ఈ పరీక్షలో అన్ని packaged components enable చేసి, Prometheus మరియు Grafana monitoring stack తో k3s v1.26.5 నడిపారు. అందువల్ల cluster ఖాళీగా కాకుండా పనిలో ఉంది. అయితే Kubernetes datastore మరియు control plane కు సంబంధించిన వినియోగాన్ని మాత్రమే ఈ గణాంకాలు చూపుతాయని, workload-specific requirements ను మినహాయిస్తాయని ప్రాజెక్ట్ చెబుతోంది. మీ containers దీనికి అదనంగా వనరులు వినియోగిస్తాయి. sqlite స్థానంలో embedded etcd ఉపయోగిస్తే RAM వినియోగం 1,606 MB కు పెరిగింది. control plane లేకుండా kubelet మరియు containerd నడిపే agent node 275 MB వినియోగించింది. Server కోసం documentation లో పేర్కొన్న కనిష్ఠ అవసరం 2 cores మరియు 2 GB RAM. ఈ కనిష్ఠం మీ workloads కు ముందు k3s మరియు దాని packaged components కు మాత్రమే వర్తిస్తుంది.

ప్రాయోగికంగా చూస్తే, 2 GB VPS పై control plane మరియు దానితో వచ్చిన add-ons కు చాలా తక్కువ వనరులు మిగులుతాయి. Memory pressure ఉన్నప్పుడు kubelet pods ను evict చేస్తుంది. అయితే memory usage వేగంగా పెరిగితే, kubelet ఆ pressure ను గుర్తించకముందే kernel యొక్క OOM killer చర్య తీసుకోవచ్చు. కొన్ని చిన్న services తో ఒకే node నడపడానికి 4 GB ఒక సౌకర్యవంతమైన కనిష్ఠ పరిమితి. ప్రచురించిన ఏ గణాంకాన్నీ, దీనినీ కలిపి, పూర్తిగా నమ్మకుండా మీ స్వంత machine పై కొలతలు తీసుకోండి.

free -h
sudo k3s kubectl top node
sudo k3s kubectl get pods -A

Install చేయడానికి ముందు, అలాగే kube-system లోని ప్రతి pod Running అని చూపించిన తర్వాత, free -h ను run చేయండి. ఈ రెండు కొలతల మధ్య తేడా మీ hardware పై control plane వినియోగించే వనరులను చూపుతుంది. Install చేసిన తర్వాత మొదటి ఒకటి లేదా రెండు నిమిషాల్లో k3s kubectl top node, error: Metrics API not available ను చూపుతుంది, ఎందుకంటే metrics-server ఇంకా ఏ data ను scrape చేయలేదు. ఇది లోపం కాదు. ఈ cluster తో పాటు ఇతర పనులను కూడా ఒకే machine పై నడపడానికి వనరులను నిర్ణయిస్తే, VPS కోసం RAM మరియు CPU పరిమాణాన్ని నిర్ణయించడం లోని లెక్కలు ఇక్కడ కూడా మార్పు లేకుండా వర్తిస్తాయి.

వెర్షన్‌ను pin చేసి k3s ఇన్‌స్టాల్ చేయండి; latest కు కాదు

అందరూ కాపీ చేసే quick start లైన్, మీరు దాన్ని అమలు చేసే రోజున stable channel సూచిస్తున్న వెర్షన్‌ను తీసుకుంటుంది. మీరు దీన్ని దీర్ఘకాలం నిర్వహించాలనుకునే మెషీన్‌లో ఉపయోగిస్తే, వెర్షన్‌ను pin చేయండి. k3s ప్రతి Kubernetes minor version కోసం ఒక channel ను విడుదల చేస్తుంది. అందువల్ల INSTALL_K3S_CHANNEL=v1.36 v1.36 లోని patch releases ను మాత్రమే అనుసరిస్తుంది. మీ అనుమతి లేకుండా ఇది minor version కు మారదు. October 2026 నాటికి stable channel v1.36.5+k3s1 ను సూచిస్తోంది.

ముందుగా config file రాయండి. తరువాత install చేయండి. k3s ప్రారంభమైనప్పుడు /etc/rancher/k3s/config.yaml ను చదువుతుంది. అందువల్ల అందులోని సెట్టింగ్‌లు మొదటి boot తో పాటు ప్రతి తదుపరి boot కు కూడా వర్తిస్తాయి.

sudo mkdir -p /etc/rancher/k3s
sudo tee /etc/rancher/k3s/config.yaml >/dev/null <<'EOF'
tls-san:
  - k3s.example.com
EOF
curl -sfL https://get.k3s.io | INSTALL_K3S_CHANNEL=v1.36 sh -

ఒక channel కు బదులుగా ఖచ్చితమైన release ను pin చేయాలంటే INSTALL_K3S_VERSION=v1.36.5+k3s1 ఉపయోగించండి. plus sign ఆ tag లో భాగమే. తరువాత అది సరిగ్గా ప్రారంభమైందో తనిఖీ చేయండి.

k3s --version
sudo systemctl status k3s
sudo k3s kubectl get node
sudo k3s kubectl get pods -A

kubectl get node సుమారు ముప్పై సెకన్లలో STATUS Ready తో ఒక node ను చూపాలి. kube-system లోని ప్రతి pod కూడా Running లేదా Completed స్థితికి చేరాలి. ఒక node NotReady వద్ద నిలిచిపోతే, సాధారణంగా container runtime ప్రారంభం కాలేదని అర్థం. అందువల్ల sudo journalctl -u k3s -n 100 --no-pager చదవండి. అసాధారణమైన VPS image లో, ఇతర debugging ప్రారంభించే ముందు sudo k3s check-config అమలు చేయండి. ఇది లేని kernel features ను చూపుతుంది. Logs చదవడం కంటే ఇది చాలా వేగంగా కారణాన్ని తెలియజేస్తుంది.

80 port ఇప్పటికే ఉపయోగంలో ఎందుకు ఉందో, దాన్ని పరిష్కరించడానికి ఏదాన్ని వదులుకోవాలో

ఇప్పటికే ఏదో సేవ అందిస్తున్న VPSలో ఈ సమస్య ఎదురవుతుంది. Installation విజయవంతమైనా, ఒకే nodeలోని మరో Kubernetes pod అదే hostPortను ఇప్పటికే reserve చేసి ఉంటే Traefikకు ఎప్పటికీ address లభించదు.

విధానం ఇలా పనిచేస్తుంది: bundled Traefik chart 80 మరియు 443 portsపై LoadBalancer రకమైన Serviceను సృష్టిస్తుంది. ఆ అభ్యర్థనకు ServiceLB స్పందించి, svclb- prefixతో పేర్లు కలిగిన చిన్న pods ఉన్న DaemonSetను సృష్టిస్తుంది. ఇవి ప్రతి nodeలో ఆ port numbersను hostPortగా claim చేస్తాయి. hostPort network rules ద్వారా node port నుంచి podకు trafficను forward చేస్తుంది. Kubernetes scheduler, Kubernetes pods ప్రకటించిన host portsను మాత్రమే పరిశీలిస్తుంది; host services లేదా standalone Docker containers కలిగి ఉన్న socketsను పరిశీలించదు. మరో pod అదే hostPortను reserve చేస్తే scheduling నిరోధించబడుతుంది. అయితే port 80పై listening చేస్తున్న nginx, Caddy, Apache లేదా standalone Docker container మాత్రమే ఈ scheduling rejectionకు కారణం కాదు.

sudo k3s kubectl -n kube-system get pods
sudo k3s kubectl -n kube-system get svc traefik
sudo ss -lntp '( sport = :80 or sport = :443 )'

మరో Kubernetes pod నుంచి conflicting hostPort reservation ఉంటే, svclb pod Pending స్థితిలోనూ, external address లేకుండా Service ఉన్నట్లుగానూ కనిపిస్తుంది:

svclb-traefik-8f2c1a-r6k9x   0/2   Pending   0   3m
traefik   LoadBalancer   10.43.62.11   <pending>   80:31480/TCP,443:30219/TCP

kubectl -n kube-system describe pod svclb-traefik-... అమలు చేస్తే కారణం నేరుగా తెలుస్తుంది:

0/1 nodes are available: 1 node(s) didn't have free ports for the requested pod ports.

ss -lntp ఏ process portపై listens చేస్తుందో చూపిస్తుంది; scheduler పరిశీలించే hostPort reservationsను ఇది చూపించదు. సమస్యను పరిష్కరించడానికి ఒకటి కంటే ఎక్కువ మార్గాలు ఉన్నాయి. ప్రతి మార్గంలో మీరు ఏదో ఒకదాన్ని వదులుకోవాలి.

Portsను k3sకు అప్పగించండి. మరో Kubernetes podలో ఉన్న conflicting hostPort reservationను తొలగించండి. ఇప్పటికే ఉన్న host web serverను stop చేసి disable చేయండి, తద్వారా 80 మరియు 443 portsపై వచ్చే trafficను Traefik నిర్వహిస్తుంది. VPSను పూర్తిగా k3s boxగా ఉపయోగించబోతున్నప్పుడు, మీరు అందిస్తున్న ప్రతిదాన్ని Ingress వెనుకకు తరలించేటప్పుడు ఇది సరైన ఎంపిక.

ServiceLBను disable చేసి, ఉన్న proxyను కొనసాగించండి. --disable=servicelbతో install చేయండి. LoadBalancer రకమైన Service అయినా NodePortను allocate చేస్తుంది. అందువల్ల Traefik 31480 వంటి high portపై అందుబాటులో ఉంటుంది, మీ nginx లేదా Caddy 127.0.0.1:31480కు proxy చేస్తుంది. మీరు వదులుకునేది external address. Service ఎప్పటికీ <pending>ను చూపిస్తుంది. మీరు తీసుకున్న నిర్ణయం వల్ల వచ్చిన స్థితి అయినప్పటికీ, అది faultలా కనిపించవచ్చు.

Traefikను disable చేసి, మీ స్వంత proxyతో route చేయండి. --disable=traefikతో install చేయండి. అప్పుడు మీ వద్ద ingress controller ఉండదు. అందువల్ల Ingress objects ఏమీ చేయవు. వాటిని గమనించే controller లేకుండా అవి APIలో మాత్రమే ఉంటాయి. Host proxy నుంచి NodePortsకు route చేసే సందర్భంలో ఇది సరైన విధానం. HTTPను ఎలా నిర్వహించాలో మీకు ఇప్పటికే స్పష్టంగా ఉంటే, ఇది నిజాయితీగల ఎంపిక. ఏ proxyని ముందు ఉంచాలో నిర్ణయించలేకపోతే, ఏదైనా disable చేయడానికి ముందు nginx, Caddy మరియు Traefikలో reverse proxyగా ఏది ఎంచుకోవాలో నిర్ణయించండి.

రెండు flagsను installerలో లేదా config fileలో ఇవ్వాలి:

tls-san:
  - k3s.example.com
disable:
  - traefik
  - servicelb

Installation తర్వాత ఆ fileను edit చేసి sudo systemctl restart k3sను అమలు చేయడం కూడా పనిచేస్తుంది. ఎందుకంటే --disable install సమయంలో componentను skip చేయడం మాత్రమే కాదు. ఇప్పటికే deployed అయిన componentను కూడా ఇది delete చేస్తుంది. అందువల్ల మార్పు నడుస్తున్న clusterపై అమలవుతుంది.

Traefikను ఉంచి chart configuration విధానాన్ని మార్చాలనుకుంటే /var/lib/rancher/k3s/server/manifests/traefik.yamlను edit చేయవద్దు. k3s ప్రతి startup సమయంలో ఆ fileను defaultsతో తిరిగి రాస్తుంది. దాని బదులుగా అదే directoryలో ప్రత్యేక fileను జోడించండి. ఎందుకంటే /var/lib/rancher/k3s/server/manifestsలో ఉన్నది startup సమయంలో మరియు diskపై మారినప్పుడల్లా స్వయంచాలకంగా apply అవుతుంది.

apiVersion: helm.cattle.io/v1
kind: HelmChartConfig
metadata:
  name: traefik
  namespace: kube-system
spec:
  valuesContent: |-
    ports:
      web:
        forwardedHeaders:
          trustedIPs:
            - 10.0.0.0/8

ఈ ఉదాహరణ ఒక Traefik chart valueను, అంటే trusted proxy addressesను, సెట్ చేస్తుంది. Chart అందించే ఇతర valuesను కూడా ఇదే విధానంతో సెట్ చేయవచ్చు. అందులో ports కూడా ఉన్నాయి.

ఒకే nodeలో persistent storage

k3s, Rancher's local-path provisioner ఆధారంగా పనిచేసే local-path అనే default StorageClass ను అందిస్తుంది. storageClassName లేకుండా సృష్టించిన PersistentVolumeClaim దీనినే ఉపయోగిస్తుంది. Volumes /var/lib/rancher/k3s/storage లో నిల్వ అవుతాయి. ప్రతి volumeకు ఒక ప్రత్యేక subdirectory ఉంటుంది. ఇవి node స్వంత diskలో ఉంటాయి.

sudo k3s kubectl get storageclass
sudo k3s kubectl get pvc -A
sudo ls -l /var/lib/rancher/k3s/storage

"node స్వంత diskలో" ఉండటం వల్ల రెండు పరిణామాలు ఉంటాయి. ఇవి వెంటనే కాకుండా తరువాత సమస్యలను కలిగిస్తాయి.

ఈ StorageClass volumeBindingMode: WaitForFirstConsumer ను ఉపయోగిస్తుంది. అందువల్ల pod దాన్ని mount చేసే వరకు కొత్త PVC Pending స్థితిలోనే ఉంటుంది. kubectl describe pvc చూపించే output:

waiting for first consumer to be created before binding

ఇది సాధారణమే. కాబట్టి PVCని మాత్రమే సృష్టించి వేచి ఉంటే దాని స్థితి మారదు.

Bind అయిన తరువాత, ఆ volumeను సృష్టించిన nodeకు node affinity జతచేయబడుతుంది. అందువల్ల ఆ claimను ఉపయోగించే ప్రతి pod, volume ఉన్నంతకాలం అదే nodeలో నడవాలి. ఒకే node ఉన్నప్పుడు ఇది కనిపించదు. తరువాత రెండవ nodeను జోడించినప్పుడు, ఒక pod మరో nodeకు మారడానికి నిరాకరించవచ్చు. అప్పుడు ఇది scheduler లోపంలా కనిపిస్తుంది. kubectl get pv -o yaml అమలు చేసిన తరువాత nodeAffinity లో hostname కనిపిస్తే అసలు కారణం తెలుస్తుంది.

Backups నిర్వహించడం మీ బాధ్యత. VPSను మళ్లీ నిర్మిస్తే ఆ directory తొలగిపోతుంది. కింద ఉన్న uninstall script అమలు చేసినా అదే జరుగుతుంది. /var/lib/rancher/k3s/storage ను backup చేయండి. అదనంగా, service ఆపిన తరువాత copy చేసిన sqlite datastore directory /var/lib/rancher/k3s/server/db/ ను కూడా backup చేయండి. ఇది live database కాబట్టి service ఆపిన తరువాతే copy చేయాలి. Server token file /var/lib/rancher/k3s/server/token ను కూడా భద్రపరచండి. ఈ token తప్పనిసరి. Backup నుంచి datastoreను restore చేసేటప్పుడు ఆ fileను restore చేయాలని లేదా దాని విలువను --token కు అందించాలని k3s documentation చెబుతుంది. మరో మార్గం clusterను తాత్కాలికంగా పరిగణించి, ప్రతి manifestను gitలో ఉంచడం.

Ingress మరియు TLS

Traefik enabled గానే ఉంటే, మీకు ఒక ప్రామాణిక Ingress object మాత్రమే అవసరం.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: hello
  annotations:
    cert-manager.io/cluster-issuer: letsencrypt
spec:
  ingressClassName: traefik
  tls:
    - hosts:
        - hello.example.com
      secretName: hello-tls
  rules:
    - host: hello.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: hello
                port:
                  number: 80

Certificates స్వయంగా ఏర్పడవు. సాధారణంగా cert-manager ను దాని published manifest నుంచి install చేసి, ఒక ClusterIssuer ను సృష్టిస్తారు. 23 October 2026న విడుదలైన v1.21.3, October 2026 నాటికి ప్రస్తుత version.

sudo k3s kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.21.3/cert-manager.yaml
apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: letsencrypt
spec:
  acme:
    email: you@example.com
    server: https://acme-v02.api.letsencrypt.org/directory
    privateKeySecretRef:
      name: letsencrypt-account-key
    solvers:
      - http01:
          ingress:
            ingressClassName: traefik

HTTP-01 challenge సమయంలో ACME (automatic certificate management environment) server public internet నుంచి http://hello.example.com/.well-known/acme-challenge/... కు connect అవుతుంది. అందువల్ల hostname యొక్క DNS record, అంటే A record లేదా VPS ను IPv6 ద్వారా చేరుకోగలిగితే AAAA record, ఇప్పటికే VPS వైపు point అయి ఉండాలి. అలాగే port 80 Traefik కు చేరాలి. A మరియు AAAA రెండూ ఉన్నప్పుడు Let's Encrypt ముందుగా IPv6 address ను ప్రయత్నిస్తుంది. ప్రారంభ IPv6 connection timeout అయితే IPv4 కు fallback అవుతుంది. తప్పు challenge response సహా ఇతర errors ఈ fallback ను trigger చేయవు. Redirect చేసిన requests కు కూడా retry లభించదు. పాత AAAA record ను సరిచేయండి లేదా తొలగించండి. ServiceLB ను disable చేసి, మీ స్వంత proxy ను ముందు ఉంచితే, ఆ proxy challenge path ను కూడా forward చేయాలి. లేకపోతే cert-manager Challenge object పై ఈ సందేశంతో నిలిచిపోతుంది:

Waiting for HTTP-01 challenge propagation: wrong status code '404', expected '200'

sudo k3s kubectl describe certificate hello-tls మరియు sudo k3s kubectl get order,challenge -A తో certificate issuance ను monitor చేయండి.

kubeconfig మరియు API server private‌గా ఎందుకు ఉండాలి

k3s admin credentials ను /etc/rancher/k3s/k3s.yaml లో రాస్తుంది. ఈ file root సొంతంగా ఉంటుంది. డిఫాల్ట్‌గా mode 600 తో రాయబడుతుంది. ఇందులో cluster-admin హక్కులు కలిగిన client certificate ఉంటుంది. అందువల్ల దీన్ని చదవగల ఎవరైనా cluster పై పూర్తి నియంత్రణ పొందగలరు.

sudo k3s kubectl get node
export KUBECONFIG=/etc/rancher/k3s/k3s.yaml
kubectl get node

విడిగా install చేసిన kubectl కు k3s file గురించి తెలియదు. KUBECONFIG సెట్ చేయకపోతే అది ~/.kube/config ను చదువుతుంది. ఆ file లేకపోతే, అసలు cluster configuration లేకపోవడం వల్ల The connection to the server localhost:8080 was refused - did you specify the right host or port? తో విఫలమవుతుంది. KUBECONFIG ను set చేయండి. క్రింద చూపిన విధంగా file ను ~/.kube/config కు copy చేయండి. లేదా sudo k3s kubectl ను ఉపయోగించండి. అది సరైన file ను స్వయంగా చదువుతుంది.

సాధారణ user kubectl నడపగలిగేలా --write-kubeconfig-mode 644 ను సిఫార్సు చేయడాన్ని మీరు చూస్తారు. అది ఏమి చేస్తుందో అర్థం చేసుకోండి: cluster-admin credential ను machine పై ఉన్న ప్రతి local account చదవగలిగేలా చేస్తుంది. ఒకే administrator ఉన్న machine పై ఇది ఆమోదయోగ్యమైన మార్పిడి కావచ్చు. Shared machine పై ఇది సరైనది కాదు. File ను copy చేస్తే దాన్ని అందరికీ వెల్లడించకుండా ఒక user కు మాత్రమే access ఇవ్వవచ్చు:

mkdir -p ~/.kube
sudo install -o $USER -g $USER -m 600 /etc/rancher/k3s/k3s.yaml ~/.kube/config

ఆ file లోని server: line https://127.0.0.1:6443 ను చదువుతుంది. మీ laptop నుంచి kubectl ఉపయోగించాలంటే 6443 ను internet కు open చేయవద్దు. Public Kubernetes API ఎల్లప్పుడూ దాడులకు లక్ష్యంగా ఉంటుంది. Exposed API వల్ల చిన్న clusters ఇతరుల కోసం cryptocurrency mining చేయడానికి దుర్వినియోగం కావచ్చు. దాన్ని SSH ద్వారా tunnel చేయండి. File లోని address ను అలాగే ఉంచండి:

ssh -N -L 6443:127.0.0.1:6443 user@your-vps
KUBECONFIG=./k3s.yaml kubectl get node

Private network address ద్వారా API ను చేరుకోవాల్సి వస్తే, ఆ name లేదా address ను tls-san లో పేర్కొంటూ install చేయండి. తరువాత copy చేసిన file లోని server: line ను దానికి సరిపడేలా edit చేయండి. SAN (subject alternative name) entry లేకపోతే kubectl connection ను తిరస్కరిస్తుంది:

x509: certificate is valid for 127.0.0.1, 10.43.0.1, not 203.0.113.10

Cluster కోసం documentation లో పేర్కొన్న inbound ports ఇవి: API కోసం TCP 6443, nodes మధ్య flannel VXLAN కోసం UDP 8472, kubelet metrics కోసం TCP 10250. Single-node cluster లో వీటిలో ఏదీ internet కు open చేయాల్సిన అవసరం లేదు.

containerd, Docker కాదు

k3s తన స్వంత embedded containerd ను నడుపుతుంది. ఇది Docker తో image store ను పంచుకోదు. మీరు ఇప్పుడే docker build తో build చేసిన image k3s కు కనిపించదు. అందువల్ల docker images దాన్ని చూపించినప్పటికీ pod ErrImagePull తో విఫలమవుతుంది. దాన్ని స్పష్టంగా import చేయండి:

docker save myapp:0.1 | sudo k3s ctr images import -
sudo k3s crictl images

ఆ container పై :latest tag ను ఉపయోగించకుండా ఉండండి. ఎందుకంటే :latest డిఫాల్ట్‌గా Always యొక్క imagePullPolicy కు సెట్ అవుతుంది. అందువల్ల kubelet ఏమైనప్పటికీ registry ను సంప్రదిస్తుంది. ఇతర ఏ tag అయినా డిఫాల్ట్‌గా IfNotPresent కు సెట్ అవుతుంది. ఇది మీరు import చేసిన image ను ఉపయోగిస్తుంది. ఒకే VPS పై రెండింటినీ నడపవచ్చు. VPS పై సాధారణ Docker installation మరియు k3s ఒకే machine లో తమ స్వంత image store లను, తమ స్వంత iptables rules ను నిర్వహిస్తాయని తెలుసుకోవడం ఉపయోగకరం.

k3s ను ఎలా తొలగించాలి

Installer ఒక uninstall script ను రాస్తుంది. పాక్షిక తొలగింపు లేదా undo విధానం ఉండదు.

sudo /usr/local/bin/k3s-uninstall.sh

ఇది service ను ఆపి తొలగిస్తుంది, datastore ను తొలగిస్తుంది, persistent volume data ను తొలగిస్తుంది, node configuration ను తొలగిస్తుంది, అలాగే installer జోడించిన tools ను తొలగిస్తుంది. Agent node పై script బదులుగా k3s-agent-uninstall.sh ఉంటుంది. /var/lib/rancher/k3s/storage లోని ఏదైనా data ను ముందుగా server నుంచి బయటకు copy చేయండి, ఎందుకంటే ఆ directory కూడా తొలగించబడుతుంది. ఆ తరువాత ports లేదా interfaces ను ఏ process అయినా ఉపయోగిస్తుందా లేదా అనేది ip link show మరియు sudo ss -lntp తో తనిఖీ చేయండి. మిగిలిపోయిన cni0 లేదా flannel.1 interface తదుపరి reboot సమయంలో తొలగిపోతుంది.

Kubernetes లోని ఒక node పని అవసరానికి మించిన అదనపు నిర్మాణంగా అనిపించి, దాన్ని తొలగించాలని నిర్ణయించడం సాధారణ పరిణామమే; అది వైఫల్యం కాదు. ఆ workloads ను తిరిగి Compose కు మార్చడం సాధారణంగా ఒక మధ్యాహ్నంలో పూర్తవుతుంది.

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

Node NotReady లేదా k3s పునఃప్రారంభ చక్రంలో ఉండటం. ముందుగా sudo journalctl -u k3s -n 200 --no-pager చదవండి. చిన్న VPSలో సాధారణ కారణం kernel out-of-memory killer ప్రక్రియను నిలిపివేయడం. ఇది dmesg లో k3s-server పేరును చూపించే పంక్తిగా కనిపిస్తుంది. డాక్యుమెంటేషన్‌లో పేర్కొన్న 2 GB కనీస పరిమితి వాస్తవమైన కనిష్ఠ అవసరం.

Pod Pending స్థితిలో నిలిచిపోవడం. ప్రతి సారి kubectl describe pod కారణాన్ని చూపిస్తుంది. Insufficient memory లేదా Insufficient cpu అంటే nodeలో స్థలం మిగలలేదు. didn't have free ports అంటే మరొక Kubernetes pod విరుద్ధమైన hostPortను reserve చేసింది. PVCపై waiting for first consumer కనిపిస్తే, WaitForFirstConsumer సరిగ్గా పనిచేస్తోందని అర్థం.

ImagePullBackOff. Node imageను pull చేయలేకపోయింది. Image పేరు మరియు tag, registry access మరియు credentials, లేదా Dockerతో imageను build చేసి containerdలోకి import చేయకపోవడం వంటి విషయాలను పరిశీలించండి.

Traefik స్పందిస్తుంది, కానీ అప్లికేషన్ స్పందించదు. 404 page not found response body Traefik నుంచే వస్తుంది. Request చేరింది కానీ ఏ router కూడా దానికి సరిపోలలేదని దీని అర్థం. Ingressలోని host మీరు టైప్ చేసిన పేరుతో సరిపోతుందో, అలాగే ingressClassName అనేది traefik కాదో పరిశీలించండి.

Host resolve అవుతున్నప్పటికీ cluster DNS విఫలమవడం. sudo k3s kubectl -n kube-system logs -l k8s-app=kube-dns తో CoreDNSను పరిశీలించండి. plugin/loop: Loop ... detected for zone "." వంటి సందేశం CoreDNS ప్రారంభం కాకుండా ఆపుతుంది. CoreDNS ఒక resolverకు forwarding చేస్తుండగా, ఆ resolver తిరిగి CoreDNSకే forwarding చేయడం వల్ల ఇది జరుగుతుంది. /etc/resolv.conf లో loopback address ఉండటం ఇదే పరిస్థితిని కలిగిస్తుంది. --resolv-conf /run/systemd/resolve/resolv.conf తో k3sను అసలు upstream fileను ఉపయోగించేలా నిర్దేశించండి.

FAQ

ఒకే VPSపై k3s నడపడం విలువైనదేనా?

మీకు Kubernetes API అవసరమైనప్పుడు ఇది విలువైనదే. మీరు నియంత్రించే మెషీన్‌పై దాన్ని నేర్చుకోవడం, deployments ను manifests రూపంలో portable గా ఉంచడం, Helm chart మాత్రమే అందించే software ను నడపడం లేదా తరువాత managed cluster కు తరలించబోయే వ్యవస్థను నిర్మించడం వంటి సందర్భాల్లో ఇది ఉపయోగకరం. కేవలం containers నడపాలనుకుంటే ఇది విలువైనది కాదు. ఎందుకంటే Docker Compose చాలా తక్కువ నిర్వహణతో అదే పని చేస్తుంది మరియు సుమారు ఒక gigabyte ఎక్కువ free RAM అందుబాటులో ఉంటుంది. ఒక node high availability ఇవ్వదు. కాబట్టి reliability కారణంగా దీన్ని ఎంచుకోవడం సరైనది కాదు.

నా k3s LoadBalancer service Pending స్థితిలోనే ఎందుకు ఉంది?

ServiceLB svclb- pods ను సృష్టిస్తుంది. ఇవి node పై service ports ను hostPort గా claim చేస్తాయి. అందువల్ల ఆ ports ఖాళీగా ఉన్న node లలో మాత్రమే ఇవి schedule అవుతాయి. మరొక Kubernetes pod అదే hostPort ను ఇప్పటికే reserve చేసి ఉంటే, pod Pending స్థితిలోనే ఉంటుంది. అప్పుడు service కు external address ఎప్పటికీ అందదు. port 80 పై వినే host proxy లేదా standalone Docker container ఉండటం మాత్రమే ఈ scheduling rejection కు కారణం కాదు. kubectl -n kube-system describe pod svclb-..., 0/1 nodes are available: 1 node(s) didn't have free ports for the requested pod ports ను report చేస్తుంది. conflicting pod యొక్క hostPort reservation ను తొలగించండి. లేదా --disable=servicelb తో ServiceLB ను disable చేసి, service ఇప్పటికీ allocate చేసే NodePort కు proxy చేయండి.

VPSపై k3s కు ఎంత RAM అవసరం?

Server node కు documented minimum 2 cores మరియు 2 GB. మీ workloads ను అమలు చేయకముందు k3s మరియు దానితో వచ్చే components కు ఇది సరిపోతుంది. Monitoring stack నడుస్తున్న సమయంలో server node యొక్క control plane మరియు datastore వినియోగాన్ని project స్వయంగా కొలిచింది. ఆ కొలత 1,596 MB. ఇందులో workload వినియోగించే memory చేర్చబడలేదు. కాబట్టి 2 GB ను కనిష్ఠ పరిమితిగా, ఒక node సౌకర్యంగా నడిచే మొదటి పరిమాణంగా 4 GB ను పరిగణించండి. Install కు ముందు ఒకసారి, అలాగే kube-system లోని ప్రతి pod Running స్థితిని చూపించిన తర్వాత మరోసారి, free -h తో మీ స్వంత machine ను కొలవండి.

ఒకే VPSపై Docker మరియు k3s రెండింటినీ నడపవచ్చా?

అవును. ఇవి వేరుగా ఉంటాయి. k3s తన స్వంత embedded containerd ను ఉపయోగిస్తుంది. అందువల్ల docker build తో build చేసిన image ను docker save myapp:0.1 | sudo k3s ctr images import - అమలు చేసే వరకు k3s చూడదు. రెండూ తమకు తాముగా iptables rules మరియు bridge networks ను సృష్టిస్తాయి. Docker, k3s మరియు మీ containers అన్నీ అదే machine యొక్క RAM ను పంచుకుంటాయి కాబట్టి మొత్తం memory వినియోగాన్ని పర్యవేక్షించండి.

k3s ను పూర్తిగా ఎలా తొలగించాలి?

Server node పై sudo /usr/local/bin/k3s-uninstall.sh ను అమలు చేయండి. Agent పై sudo /usr/local/bin/k3s-agent-uninstall.sh ను అమలు చేయండి. ఇది service ను ఆపుతుంది, datastore ను తొలగిస్తుంది, /var/lib/rancher/k3s/storage కింద ఉన్న persistent volume data ను తొలగిస్తుంది మరియు bundled tools ను తీసివేస్తుంది. ఉంచుకోవాలనుకునే data ను ముందుగా machine బయటకు copy చేయండి. ఎందుకంటే ఈ చర్యను undo చేయలేరు. మిగిలిపోయిన cni0 లేదా flannel.1 network interface తదుపరి reboot సమయంలో తొలగించబడుతుంది.

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

#kubernetes#k3s#docker-compose#ingress#sizing