VPSలో Docker నడిపితే నిజంగా ఏమి మారుతుంది
VPSలో Docker engine అదే అయినా పరిమిత RAM వల్ల processలు terminate కావచ్చు, published ports UFWని దాటవచ్చు, reboot తర్వాత containers ఆగిపోవచ్చు, disk నిండిపోవచ్చు.
VPSపై Docker నడిపినప్పుడు ఏమి మారుతుంది
VPSపై Docker, మీ laptopలోని Docker ఉపయోగించే అదే engine మరియు అదే imagesను ఉపయోగిస్తుంది. అందువల్ల మీకు ఇప్పటికే తెలిసిన ప్రతి command ఇప్పటికీ పనిచేస్తుంది. మారేది దాని చుట్టూ ఉన్న వాతావరణం. Laptopలో అదనపు memory ఉంటుంది. ఎవరూ scan చేయని firewall ఉంటుంది. మీరు diskను పరిశీలించాల్సిన అవసరం లేకుండా ఉండేంత పెద్దదిగా అది ఉంటుంది. అద్దెకు తీసుకున్న serverకు memory పరిమితి స్థిరంగా ఉంటుంది. దానికి ఉన్న public IP address boot చేసిన కొద్ది నిమిషాల్లోనే scan చేయబడుతుంది. Docker root filesystemను అనుమతి అడగకుండా నింపుతుంది.
చిన్న serverలో ఎక్కువ సమస్యలకు కారణమయ్యే నాలుగు తేడాలు ఇవి:
- Memory పరిమితమైనది. కొరత ఏర్పడితే kernel ఒక processను terminate చేస్తుంది.
- Published port నేరుగా UFW (uncomplicated firewall)ను దాటి వెళ్తుంది, ఎందుకంటే Docker తన సొంత firewall rulesను రాస్తుంది.
- మీరు ముందుగానే ఆ విధంగా configure చేయకపోతే reboot తర్వాత containers మళ్లీ ప్రారంభం కావు.
- Disk పూర్తిగా నిండే వరకు images, containers, volumes మరియు build cache పెరుగుతూనే ఉంటాయి.
క్రింది ప్రతి sectionలో సమస్య, మీరు వాస్తవంగా చూసే string, అలాగే దాన్ని లోతుగా పరిష్కరించే guide వివరించబడతాయి. మీరు ఇంకా compose file రాయకపోతే, ముందుగా VPSపై Docker Compose ప్రాథమికాలు చదివి తిరిగి రండి. మీరు ఇప్పటికే ఒక stackను ప్రారంభించగలరని ఈ పేజీ భావిస్తుంది.
Docker container ఎంత RAM ఉపయోగిస్తుంది?
చాలామంది ఊహించేదానికంటే తక్కువ. Container అనేది virtual machine కాదు; అది cgroup (control group) లో నడిచే process. అందువల్ల guest kernel ఉండదు, fixed allocation కూడా ఉండదు. Container లోని process తాకే memory మేరకే ఖర్చు ఉంటుంది. అందుకే virtual machines తో నిర్మించిన అదే stack కు సాధ్యం కాని విధంగా, పూర్తి stack 2 GB లో సరిపోవచ్చు.
క్రింది గణాంకాలు Ubuntu 24.04 పై default configuration తో నడిచే stock images కు సంబంధించిన సాధారణ idle సంఖ్యలు. Start చేసిన కొన్ని నిమిషాల తర్వాత docker stats నుంచి ఇవి చదవబడ్డాయి. ఇవి planning కోసం ప్రారంభ అంచనాలు మాత్రమే; మీ workload కు benchmark కావు. ఏ గణాంకాన్నైనా, వీటినీ కలుపుకుని, నమ్మే ముందు మీ స్వంత box పై docker stats --no-stream అమలు చేయండి.
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
{
"label": "nginx",
"idle_mb": 8,
"budget_mb": 64
},
{
"label": "Redis 7",
"idle_mb": 12,
"budget_mb": 128
},
{
"label": "Traefik v3",
"idle_mb": 40,
"budget_mb": 128
},
{
"label": "PostgreSQL 16",
"idle_mb": 45,
"budget_mb": 512
},
{
"label": "Uptime Kuma",
"idle_mb": 95,
"budget_mb": 256
},
{
"label": "MariaDB 11",
"idle_mb": 190,
"budget_mb": 512
},
{
"label": "Nextcloud (Apache)",
"idle_mb": 210,
"budget_mb": 768
}
]ఈ రెండు columns వేర్వేరు పనులు చేస్తాయి. idle_mb ఏ పని చేయకుండా ఉన్నప్పుడు container ఉపయోగించే memory. budget_mb planning సమయంలో reserve చేయాల్సిన memory, ఎందుకంటే వాస్తవ వినియోగం idle గా ఉండదు. Connections, sorts మరియు cache active అయిన తర్వాత PostgreSQL idle స్థాయికి సమీపంలోని 45 MB నుంచి 512 MB కోరుతుంది. Planning ను budget column ఆధారంగా చేయండి. Debugging ను idle column ఆధారంగా చేయండి.
ఆ 7 rows నమూనాను గమనించండి. nginx 8 MB వద్ద idle గా ఉంటుంది; Nextcloud 210 MB వద్ద ఉంటుంది. మీ applications ముందు ఉన్న proxy దాదాపు memory ఉపయోగించదు. మీరు box capacity నిర్ణయించేటప్పుడు ప్రధానంగా database మరియు PHP application కోసం memory కేటాయించాలి.
docker stats గురించి ఒక హెచ్చరిక: container స్వంత file reads ద్వారా లోడ్ చేసిన page cache కూడా memory గణాంకంలో ఉంటుంది. అందువల్ల start చేసిన తర్వాత కొంతసేపు memory పెరిగి, తరువాత స్థిరపడుతుంది. ఏదైనా memory leak ఉందని నిర్ణయించే ముందు ఒక గంట పాటు దాన్ని monitor చేయండి.
VPS పరిమాణం: 2 GB, 4 GB మరియు 8 GBలో ఏవి సరిపోతాయి
ముందుగా host వినియోగాన్ని మొత్తం బడ్జెట్ నుంచి తీసివేయండి. Kernel, systemd, journald, sshd మరియు Docker daemon మీ containers ఉపయోగించే అదే RAMలోనే నడుస్తాయి. dockerd మరియు containerd కలిసి అందులో సుమారు 100 MB ఉపయోగిస్తాయి. Page cache కోసం, అలాగే image build లేదా database dump నడుస్తున్నప్పుడు ఏర్పడే memory spike కోసం కూడా కొంత memory ఖాళీగా ఉంచాలి.
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
{
"plan": "2 GB VPS",
"total_mb": 2048,
"host_reserve_mb": 768,
"container_mb": 1280
},
{
"plan": "4 GB VPS",
"total_mb": 4096,
"host_reserve_mb": 1024,
"container_mb": 3072
},
{
"plan": "8 GB VPS",
"total_mb": 8192,
"host_reserve_mb": 1536,
"container_mb": 6656
}
]host_reserve_mbలో operating system, Docker daemon మరియు load సమయంలో system సజావుగా స్పందించేలా ఉంచే అదనపు headroom ఉంటాయి. మిగిలినది container_mb. మీరు ఉపయోగించగల ఏకైక మొత్తమిదే. చిన్న planలో ఈ reserve 768 MB నుంచి పెద్ద planలో 1536 MB వరకు పెరుగుతుంది. పెద్ద host ఎక్కువ containers నడుపుతుంది, ఎక్కువ logs రాస్తుంది మరియు ఎక్కువ page cache అవసరం చేసుకుంటుంది.
2 GB plan containers కోసం 1280 MB మిగులుస్తుంది. అందులో 512 MBను PostgreSQLకు, 128 MBను Traefikకు కేటాయిస్తే, సగం memory ఇప్పటికే ఉపయోగించబడుతుంది. మిగిలిన memoryతో సుమారు 256 MB చొప్పున రెండు చిన్న అప్లికేషన్లు నడపవచ్చు. ఇది వాస్తవికంగా ఉపయోగకరమైన server. అయితే దీనిపై Nextcloud మరియు search clusterను కూడా నడపడానికి తగినంత స్థలం ఉండదు.
4 GB plan 3072 MB మిగులుస్తుంది. ఇందులో database, reverse proxy, మూడు అప్లికేషన్లు మరియు monitoring containerను ఒకేసారి నడపవచ్చు. మీరు ముఖ్యంగా ఉపయోగించే ఏ పనికైనా ఇది ఉపయోగించదగిన కనిష్ఠ పరిమాణం. అదనపు memory వల్ల విఫలమైన deploy సమయంలో ఏర్పడే ఒత్తిడిని system తట్టుకోగలుగుతుంది.
8 GB planలోని 8192 MBలో 6656 MB మిగులుతుంది. ఈ స్థాయిలో పరిమితి సాధారణంగా memory కాకుండా CPU లేదా disk throughput అవుతుంది. SSD Nodes దీనికంటే చిన్న planలను అందించదు. దాని చిన్న planలో 8 GB RAM ఉంది (pricing pageను 2026-10-11న పరిశీలించారు). అందువల్ల ఆ hostకు ఈ వరుస వర్తిస్తుంది. 2 GB మరియు 4 GB వరుసలు ఇతర providers అందించే చిన్న hostsను సూచిస్తాయి. కొన్ని container పరిమాణాలు load ఆధారంగా కాకుండా configuration ఆధారంగా నిర్ణయించబడతాయి. ఉదాహరణకు, local model server తన context window పరిమాణానికి అనుపాతంగా KV cacheను reserve చేస్తుంది. అందువల్ల ఒక్క request కూడా రాకముందే Ollama యొక్క num_ctxను పెంచడం బడ్జెట్కు gigabytesను జోడించవచ్చు. మీ stack సరిపోదని లెక్కలు చూపిస్తే, దాన్ని సర్దుబాట్లతో నడపడానికి ప్రయత్నించకుండా పెద్ద plan కొనండి. VPS వాస్తవంగా ఎంత ఖర్చవుతుంది అనే విభాగంలో అదనపు gigabytesకు నెలకు చెల్లించే మొత్తం వివరించబడింది.
లెక్కలు వాస్తవికంగా ఉండేందుకు రెండు నియమాలు పాటించండి. ప్రతి serviceకు memory limit కేటాయించండి. అప్పుడు అదుపు తప్పిన ఒక process మొత్తం hostను ప్రభావితం చేయదు. అలాగే బడ్జెట్లోని పైభాగాన్ని ఖాళీగా ఉంచండి. ఎందుకంటే అత్యంత అవసరమైన సమయంలో docker compose build మరియు pg_dump రెండింటికీ memory అవసరం అవుతుంది. Docker Composeలో memory limitsలో syntax మరియు సాధారణ సమస్యలు వివరించబడ్డాయి.
నా container code 137తో ఎందుకు exit అవుతోంది?
Kernel దాన్ని terminate చేసింది. 137 అనేది 128 plus 9. Signal 9 పేరు SIGKILL. Container కు అనుమతించిన memory కంటే ఎక్కువ memory అవసరమైంది. అందువల్ల out of memory (OOM) killer దాన్ని terminate చేసింది.
CONTAINER ID IMAGE STATUS
9f2c1a4d7b3e postgres:16 Exited (137) 4 minutes agoఊహాగానాలు చేయకుండా కారణాన్ని నిర్ధారించండి:
docker inspect my-db | grep -i oomkilled
sudo journalctl -k | grep -i "out of memory""OOMKilled": true అంటే container తన స్వంత cgroup limit ను చేరుకుంది. Kernel log అది ఎంచుకున్న process పేరును చూపిస్తుంది:
Memory cgroup out of memory: Killed process 2417 (postgres) total-vm:1284416kBఇది మంచి పరిస్థితి. ఎందుకంటే నష్టం ఒకే container కు పరిమితమవుతుంది. Limit అసలు లేని container చెడు పరిస్థితిని కలిగిస్తుంది. Limit లేకపోతే దాని గరిష్ఠ పరిమితి మొత్తం machine memory అవుతుంది. అందువల్ల ఒక service లోని memory leak host లోని memory ని ఖాళీ చేస్తుంది. తరువాత kernel మొత్తం system లో memory పరిమాణం ఆధారంగా ఒక victim ను ఎంచుకుంటుంది. Log line లో Memory cgroup prefix ఉండదు. అది Out of memory: Killed process 2417 (postgres) గా కనిపిస్తుంది. Kernel ఎంచుకునే process తరచుగా మీ database అవుతుంది. అయితే memory leak చేసిన container మాత్రం నడుస్తూనే ఉంటుంది. అందుకే ప్రతి service కు limit పెట్టడం, ఏదైనా ఒక్క limit యొక్క ఖచ్చితమైన విలువ కంటే ముఖ్యమైనది.
Swap సమయాన్ని మార్చుతుంది. లెక్కను మార్చదు. చాలా VPS images లో swap ఉండదు. swapon --show తో తనిఖీ చేయండి. Swap లేకపోతే ఇది ఏ output ను చూపించదు. Swap file ఉంటే cold pages ను ఉంచడానికి kernel కు స్థలం లభిస్తుంది. సమస్యను గుర్తించడానికి ఇది మీకు కొన్ని నిమిషాల సమయం ఇస్తుంది.
sudo fallocate -l 2G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab
free -hఇప్పుడు Swap row లో free -h non-zero total ను చూపించాలి. Swap, RAM ను పెంచదు. నిరంతర memory pressure ఉన్న machine చాలా నెమ్మదిగా మారవచ్చు. అప్పుడు సమస్యను పరిష్కరించడానికి మీరు SSH ద్వారా login కాలేకపోవచ్చు. కాబట్టి swap ను alarm buffer గా పరిగణించి, memory sizing ను సరిచేయండి.
UFW ప్రచురించిన Docker port ను ఎందుకు block చేయదు?
ఎందుకంటే ఆ traffic UFW పర్యవేక్షించే chain కు చేరదు. -p 5432:5432 తో port publish చేసినప్పుడు లేదా compose లో ports: entry ఉపయోగించినప్పుడు, daemon nat table లో DNAT (destination network address translation) rule ను, అలాగే తన స్వంత DOCKER chain లో accept rule ను రాస్తుంది. Container కు ఉద్దేశించిన packet host కు deliver కాకుండా ఆ container కు forward అవుతుంది. అందువల్ల అది FORWARD మార్గంలో handle అవుతుంది, UFW రాసే INPUT rules ను దాటదు.
Server పై ఇది ఎలా జరుగుతుందో చూడవచ్చు:
sudo ufw status | grep 5432
sudo iptables -t nat -L DOCKER -n | grep 5432nat table లో అదే port కోసం DNAT tcp ... to:172.18.0.2:5432 rule ఉన్నప్పటికీ, UFW 5432 DENY IN Anywhere ను print చేయవచ్చు. మరో machine నుంచి nc -vz your.server.ip 5432 ఇప్పటికీ connect అవుతుంది. Database public internet కు అందుబాటులో ఉంటుంది, కానీ firewall అది అందుబాటులో లేదని చెబుతుంది.
దీనికి పరిష్కారం తక్కువ ports ను publish చేయడం. ఒకే compose project లోని containers ఒక network ను share చేసుకుంటాయి. అవి service name ద్వారా ఒకదానితో ఒకటి connect అవుతాయి. కాబట్టి పక్కనే ఉన్న application కు మాత్రమే సేవలందించే database కు ports: entry అవసరం లేదు. Local access కావాలంటే publish ను loopback కు bind చేయండి:
services:
db:
image: postgres:16
ports:
- "127.0.0.1:5432:5432"docker compose up -d తర్వాత బయట నుంచి nc -vz your.server.ip 5432 విఫలమవుతుంది. అయితే box పై psql -h 127.0.0.1 -p 5432 ఇప్పటికీ పనిచేస్తుంది. సక్రమంగా అమర్చిన చిన్న stack లో reverse proxy మాత్రమే 80 మరియు 443 పై ఏదైనా publish చేస్తుంది. Port తప్పనిసరిగా publish చేసి, దానిపై filtering చేయాల్సిన సందర్భాల కోసం Docker published ports UFW ను ఎలా bypass చేస్తాయి లో DOCKER-USER chain గురించి వివరించారు. దిగువ host rules కోసం UFW firewall ప్రాథమికాలు చూడండి.
నా containers reboot తర్వాత ఎందుకు కనిపించకుండా పోయాయి?
వాటిని తిరిగి ప్రారంభించమని ఏదీ చెప్పలేదు. మీరు restart policy సెట్ చేయకపోతే, container no policyతో సృష్టించబడుతుంది. అందువల్ల reboot తర్వాత అది stopped స్థితిలోనే ఉంటుంది. daemon కూడా దీనిని పట్టించుకోదు. VPSలో reboots అరుదు కావు. unattended upgrades ద్వారా వచ్చే kernel updates, provider maintenance, అలాగే పై వివరించిన OOM sequence ఇవన్నీ rebootకు దారితీయవచ్చు.
రెండు విషయాలు తప్పనిసరిగా నిజం కావాలి. daemon boot సమయంలో ప్రారంభం కావాలి:
systemctl is-enabled dockerసాధారణ Ubuntu installలో ఇది enabled ను చూపిస్తుంది. తరువాత ప్రతి serviceకు ఒక policy అవసరం:
services:
app:
image: ghcr.io/example/app:1.4
restart: unless-stoppedunless-stopped reboot తర్వాత containerను తిరిగి ప్రారంభిస్తుంది. మీరు ఉద్దేశపూర్వకంగా ఆపిన containerను ఇది గౌరవిస్తుంది. always మీరు ఉద్దేశపూర్వకంగా ఆపిన containersను కూడా daemon restart అయిన ప్రతిసారి తిరిగి ప్రారంభిస్తుంది. Debugging మధ్యలో ఇది అనుకోని ప్రవర్తన కావచ్చు. Fileను మార్చడం మాత్రమే సరిపోదు. Container సృష్టించబడిన సమయంలోనే restart policy సెట్ అవుతుంది. అందువల్ల దాన్ని మళ్లీ సృష్టించేందుకు docker compose up -d అమలు చేయండి. తరువాత ప్రస్తుత valueను పరిశీలించండి:
docker inspect my-app | grep -A3 RestartPolicyతరువాత ఉద్దేశపూర్వకంగా serverను reboot చేసి, project directoryలో docker compose ps అమలు చేయండి. Planned rebootను తట్టుకునే stack, unplanned rebootను కూడా తట్టుకుంటుంది. మీ stackకు startup order హామీ లేదా boot సమయంలో ఒకసారి మాత్రమే నడిచే job అవసరమైతే, systemd unit మెరుగైన సాధనం. boot సమయంలో Docker Compose ప్రారంభించడంలో unit file ఉంది. తిరిగి ప్రారంభమైన container నిజంగా service అందిస్తుందో తెలుసుకోవడానికి Compose healthchecks జోడించండి.
నా VPS డిస్క్ ఎందుకు పూర్తిగా నిండిపోయింది?
మీరు ఆపమని చెప్పే వరకు Docker అన్నింటినీ నిల్వ చేస్తుంది. మీరు ఎప్పుడైనా pull చేసిన ప్రతి image tag, ఆపివేసిన ప్రతి container, recreate సమయంలో మిగిలిపోయిన ప్రతి anonymous volume, అలాగే build cache లోని ప్రతి layer డిస్క్లోనే ఉంటుంది. పెద్ద డిస్క్ కొంత అదనపు సమయం మాత్రమే ఇస్తుంది. SSD Nodes యొక్క చిన్నతరహా plan లోని 160 GB SSD కూడా (ధరల పేజీని 2026-10-11న పరిశీలించారు) ప్రతి వారం images pull చేసి build చేసే serverలో ఇదే విధంగా నిండిపోతుంది. చిన్న root filesystem ఉంటే outage మరింత త్వరగా ఏర్పడుతుంది.
డిస్క్ పూర్తిగా నిండిపోవడం crash లాగా కనిపించదు. అదే గంటలో container నుంచి, no space left on device నుంచి, journald నుంచి, అలాగే docker pull నుంచి మీకు apt వస్తుంది. PostgreSQL writes స్వీకరించడం ఆపేస్తుంది. Server ఇంకా పనిచేస్తూనే ఉంటుంది. అందువల్ల reboot loop కంటే సమస్యను గుర్తించడం కష్టంగా ఉంటుంది.
ఏదైనా తొలగించే ముందు పరిస్థితిని పరిశీలించండి:
docker system df
df -h /docker system df మొత్తం వినియోగాన్ని images, containers, local volumes, build cacheగా విభజిస్తుంది. ప్రతి విభాగం పక్కన RECLAIMABLE column ఉంటుంది. స్వయంగా images build చేసే serverలో build cache సాధారణంగా అతిపెద్ద విభాగంగా ఉంటుంది.
docker image prune -a
docker builder prune
docker system dfఏ container ఉపయోగించని ప్రతి image ను docker image prune -a తొలగిస్తుంది. Build cache ను docker builder prune తొలగిస్తుంది. Services నడుస్తున్నప్పటికీ ఇవి రెండూ సురక్షితమే, ఎందుకంటే ఉపయోగంలో ఉన్న వాటిని దాటవేస్తాయి. సురక్షితం కానిది docker system prune --volumes. ఇది ఆపివేసిన containers ను తొలగిస్తుంది. ఆ తరువాత మిగిలిన ఏ container ఉపయోగించని ప్రతి anonymous volume ను కూడా తొలగిస్తుంది. వారాంతం కోసం ఆపివేసిన stack సాధారణంగా ఇలానే ఉంటుంది. దాని database data ను anonymous volume లో ఉంచి ఉంటే, image volume ను ప్రకటించినప్పుడు మరియు మీ compose file అక్కడ ఏదీ mount చేయనప్పుడు Docker సృష్టించేది అదే anonymous volume, ఆ data కూడా తొలగిపోతుంది. Named volumes ఈ command తర్వాత మిగిలి ఉంటాయి. అయితే docker volume prune --all ఉపయోగించని named volumes ను కూడా తొలగిస్తుంది. ఏదైనా flag ఉపయోగించే ముందు bind mounts మరియు named volumes మధ్య తేడాలు చదవండి. ముందుగా backup తీసుకోండి.
Container logs నెమ్మదిగా పెరుగుతాయి, కానీ అవి కూడా డిస్క్ను నింపుతాయి. Default json-file driver కు size limit ఉండదు. అందువల్ల ఎక్కువ logs రాసే ఒక container /var/lib/docker/containersలో gigabytes డేటాను నిల్వ చేయగలదు. ప్రతి container కోసం /etc/docker/daemon.jsonలో దీనికి పరిమితి పెట్టండి:
{
"log-driver": "json-file",
"log-opts": {
"max-size": "10m",
"max-file": "3"
}
}దీనిని sudo systemctl restart dockerతో అమలు చేయండి. ఇది మీ containers ను restart చేస్తుంది కాబట్టి సరైన సమయాన్ని ఎంచుకోండి. ఈ పరిమితి మార్పు తర్వాత సృష్టించే containers కు మాత్రమే వర్తిస్తుంది. అందువల్ల నడుస్తున్న containers ను docker compose up -d --force-recreateతో recreate చేసి, తరువాత నిర్ధారించండి:
docker inspect my-app | grep -A5 LogConfig
sudo du -sh /var/lib/docker/containersInspect output లో max-size సెట్ అయి ఉండాలి. అది ఖాళీగా ఉంటే, ఆ container ఈ మార్పుకు ముందు సృష్టించబడింది. అది ఇంకా ఎలాంటి పరిమితి లేకుండా logs రాస్తోంది.
చిన్న Docker హోస్ట్ను ఆరోగ్యంగా ఉంచే అలవాట్లు
వీటిలో దేనికీ dashboard లేదా మీరు నేర్చుకోవాల్సిన tool అవసరం లేదు.
- నెలలో మొదటి రోజున
docker system dfమరియుdf -h /ను అమలు చేయండి. రెండు commands, ముప్పై seconds. outage గా మారకముందే trend కనిపిస్తుంది. - మీరు చిన్నవే అని నమ్మే services తో సహా ప్రతి service కు memory limit ఇవ్వండి. ఈ limit host-wide outage ను ఒక container restart కు పరిమితం చేస్తుంది.
- ఆ box ను వేరే చోటు నుంచి monitor చేయండి. అప్పుడు kernel చర్య తీసుకునేలోపు memory లేదా disk pressure గురించి తెలుసుకుంటారు. Uptime Kuma ఒక container లో నడుస్తుంది. ఇది idle సమయంలో సుమారు 95 MB memory ఉపయోగిస్తుంది.
- containers ను కాదు, volumes ను backup చేయండి. container ను తొలగించి మళ్లీ సృష్టించవచ్చు. volume ను అలా పరిగణించకూడదు. VPS పై restic backups schedule మరియు restore test రెండింటినీ కవర్ చేస్తుంది.
- compose file లో image tags ను pin చేయండి. మీరు ఎంచుకున్న రోజున వాటిని update చేయండి.
latestను ఉపయోగిస్తే, తదుపరిdocker compose pullనుంచి పొందే version ఆ ఉదయం విడుదలైనదే అవుతుంది.
నాలుగు సంఖ్యలు నియంత్రణలో ఉన్నంతకాలం Docker నడుస్తున్న చిన్న VPS సంవత్సరాల పాటు ఆరోగ్యంగా ఉంటుంది: memory budget, published ports జాబితా, ప్రతి service కు restart policy, మరియు ఖాళీ disk స్థలం. మిగతావన్నీ మీరు ఇప్పటికే ఇంట్లో నడుపుతున్న అదే Docker.
FAQ
Docker ను VPS పై నడపడానికి ఎంత RAM అవసరం?
Docker స్వయంగా తక్కువ వనరులను ఉపయోగిస్తుంది. Daemon మరియు containerd కలిపి సుమారు 100 MB ఉపయోగిస్తాయి. మిగిలిన అవసరం మీ containers పై ఆధారపడి ఉంటుంది. ముందుగా host కోసం అవసరమైన భాగాన్ని కేటాయించండి: 768 MB ఉన్న 2048 MB సిస్టమ్లో operating system, daemon మరియు అదనపు headroom కోసం ఈ మొత్తాన్ని ఉంచాలి. దాంతో containers కోసం 1280 MB మిగులుతుంది. 512 MB ఉపయోగించే database, 128 MB ఉపయోగించే reverse proxy మరియు రెండు చిన్న applications ఇందులో సరిపోతాయి. ప్రచురించిన గణాంకాలను నమ్మడం కంటే docker stats --no-stream తో మీ స్వంత stack వినియోగాన్ని కొలవండి.
1 GB VPS పై Docker ను నడపవచ్చా?
అవును. ఒకటి లేదా రెండు తేలికపాటి containers కోసం నడపవచ్చు. ప్రారంభించే ముందు swap file ను కూడా ఏర్పాటు చేయండి. Operating system మరియు Docker daemon నడుస్తున్నప్పుడు 1 GB సిస్టమ్లో సుమారు సగం మెమరీ వినియోగమవుతుంది. మిగిలినది ఒక చిన్న application మరియు reverse proxy కి సరిపోతుంది. అయితే నిజమైన లోడ్లో database కు సరిపోదు. ఇంత చిన్న సిస్టమ్లో images build చేస్తే build విఫలమవచ్చు లేదా మరొక process ముగిసిపోవచ్చు. అందువల్ల images ను వేరే చోట build చేసి, సిద్ధమైన image ను pull చేయండి.
UFW Docker container ను రక్షిస్తుందా?
మీరు publish చేసే ports కు కాదు. Docker స్వంత DNAT మరియు forward rules ను రాస్తుంది. అందువల్ల published container port కు వచ్చిన packet host కు అందకుండా container కు forward అవుతుంది. UFW నిర్వహించే INPUT rules ఆ packet ను చూడవు. ufw deny 5432 సక్రియంగా ఉన్నప్పటికీ, ఆ port ఇంటర్నెట్ నుంచి సమాధానం ఇవ్వవచ్చు. 127.0.0.1:5432:5432 తో loopback కు మాత్రమే publish చేయండి, అంతర్గత services ను unpublished గా ఉంచండి లేదా DOCKER-USER chain లో filter చేయండి.
VPS reboot తర్వాత నా containers మళ్లీ ప్రారంభమవుతాయా?
అవి restart policy తో సృష్టించబడితే మాత్రమే. ప్రతి service పై restart: unless-stopped ను సెట్ చేయండి. Restart policy తో containers ను మళ్లీ సృష్టించడానికి docker compose up -d అమలు చేయండి. తరువాత systemctl is-enabled docker, enabled ను చూపిస్తుందో నిర్ధారించండి. ఉద్దేశపూర్వకంగా reboot చేసి docker compose ps ను తనిఖీ చేయండి. ఎప్పుడూ పరీక్షించని restart policy నిజమైన restart policy కాదు.
Docker images ను ఎంత తరచుగా prune చేయాలి?
చాలా చిన్న servers కు నెలకు ఒకసారి సరిపోతుంది. లేదా docker system df చూపించే reclaimable space మీకు అవసరమైనప్పుడు prune చేయండి. Services నడుస్తున్న సమయంలో docker image prune -a మరియు docker builder prune రెండూ సురక్షితమే, ఎందుకంటే ఉపయోగంలో ఉన్న images మరియు cache ను అవి వదిలివేస్తాయి. ఏ volumes unreferenced గా ఉన్నాయో ఖచ్చితంగా తెలిసినప్పుడు మాత్రమే docker system prune --volumes ను ఉపయోగించండి. ఎందుకంటే ఆ సమయంలో ఆగి ఉన్న ఏ stack కు చెందిన anonymous volumes అయినా అది తొలగిస్తుంది. docker volume prune --all ఉపయోగంలో లేని named volumes ను కూడా తీసుకుంటుంది.