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

VPSలో Docker డిస్క్ స్థలాన్ని ఖాళీ చేయడం ఎలా

VPS డిస్క్ నిండితే ముందుగా images, containers, build cache, volumesలో స్థలాన్ని ఏది తీసుకుంటుందో కనుగొనండి. డేటా కోల్పోకుండా సరైన Docker prune ఆదేశాన్ని ఎంచుకోండి.

ఏదైనా prune చేసే ముందు డిస్క్ స్థలాన్ని ఏది ఉపయోగిస్తుందో కనుగొనండి

VPSలో Docker డిస్క్ స్థలాన్ని నాలుగు చోట్ల ఉపయోగిస్తుంది: images, stopped containers, build cache మరియు local volumes. స్థలాన్ని వీటిలో ఏది ఉపయోగిస్తుందో తెలుసుకోవడానికి ముందుగా docker system df అమలు చేయండి. తరువాత దాన్ని తొలగించడానికి అవసరమైనంత పరిమితమైన prune కమాండ్‌ను అమలు చేయండి. క్రమం ముఖ్యం. ఈ గైడ్‌లోని చివరి కమాండ్ అయిన docker volume prune -a డేటాను తొలగిస్తుంది. దాన్ని తిరిగి రద్దు చేయలేరు.

Dockerతో ప్రారంభించకుండా filesystemతో ప్రారంభించండి.

df -h /
sudo du -xh --max-depth=1 /var/lib/docker | sort -h
sudo du -xh --max-depth=1 /var/lib/containerd | sort -h

స్థితి ఎంత తీవ్రంగా ఉందో df తెలియజేస్తుంది. స్థలం ఎక్కడ ఉపయోగించబడుతుందో du తెలియజేస్తుంది. -x flag du ను ఒకే filesystemకు పరిమితం చేస్తుంది. అందువల్ల అది వేరే volumeలోని mountలోకి వెళ్లి దాన్ని రెండుసార్లు లెక్కించదు. ఏ directories ముఖ్యమో storage backendపై ఆధారపడి ఉంటుంది. Docker Engine 29.0 లేదా తరువాతి వెర్షన్‌ను కొత్తగా install చేసినప్పుడు containerd image store defaultగా ఉంటుంది. అందులో image contents మరియు container snapshots /var/lib/containerd లో ఉంటాయి. అందుకే రెండో du line ఉంది. ఏ backend అయినా /var/lib/docker కింద ఉన్న రెండు directories ముఖ్యమైనవి: volumes లో volume data ఉంటుంది, containers లో container metadata మరియు log files ఉంటాయి. పాత Docker నుంచి upgrade చేసిన host, backendను మార్చే వరకు classic overlay2 layoutను కొనసాగిస్తుంది. ఆ layoutలో మరో మూడు directories ముఖ్యమైనవి: overlay2 లో image మరియు container layers ఉంటాయి, buildkit లో build cache ఉంటుంది, image లో layer metadata ఉంటుంది. containerd image storeలో docker info | grep -i driver-type, io.containerd.snapshotter.v1 ను ప్రింట్ చేస్తుంది; overlay2 వద్ద ఏమీ ప్రింట్ చేయదు. containerd image store ప్రతి layerకు compressed copyతో పాటు extracted copyని కూడా ఉంచుతుంది. అందువల్ల overlay2 కింద ఉన్నదానికంటే అదే images ఎక్కువ డిస్క్ స్థలాన్ని ఉపయోగిస్తాయి.

sudo మరియు shell wildcards గురించి ఒక ముఖ్యమైన విషయం ఉంది. దీనివల్ల చాలామంది ఎక్కువ సమయం వృథా చేస్తారు. /var/lib/docker rootకు చెందినది. మీ సాధారణ user దాన్ని చదవలేరు. అందువల్ల ls /var/lib/docker, Permission denied ను తిరిగి ఇస్తుంది. sudo du -sh /var/lib/docker/* వంటి command కూడా విఫలమవుతుంది. ఎందుకంటే sudo అమలు కాకముందే మీ shell * ను expand చేస్తుంది. మీ shell ఆ directoryని చదవలేరు. అందుకే క్రింది ప్రతి command wildcardకు బదులుగా find లేదా --max-depth ను ఉపయోగిస్తుంది.

ఇప్పుడు Docker స్వయంగా చూపించే వివరాలను చూడండి.

docker system df
TYPE            TOTAL     ACTIVE    SIZE      RECLAIMABLE
Images          24        6         12.4GB    8.91GB (71%)
Containers      31        6         1.42GB    1.39GB (97%)
Local Volumes   14        5         6.03GB    4.11GB (68%)
Build Cache     212       0         9.87GB    9.87GB

ఈ గణాంకాలు ఒకే machine నుంచి వచ్చాయి. అవి మీ machine గురించి ఏమీ చెప్పవు. వాటి ఆకృతిని పరిశీలించండి. TOTAL మొత్తం objects సంఖ్యను లెక్కిస్తుంది. ACTIVE ప్రస్తుతం ఉపయోగంలో ఉన్న objects సంఖ్యను లెక్కిస్తుంది. RECLAIMABLE ఆ row నుంచి prune ద్వారా ఎంత స్థలాన్ని ఖాళీ చేయవచ్చో Docker వేసిన అంచనా.

RECLAIMABLE గురించి రెండు విషయాలు గందరగోళానికి గురిచేస్తాయి. ఒకే image layersను ఉపయోగించే ప్రతి imageకు shared image layersను అది ఒక్కసారి చొప్పున లెక్కిస్తుంది. అందువల్ల image row సాధారణంగా వాస్తవంగా లభించే స్థలం కంటే ఎక్కువ స్థలాన్ని చూపిస్తుంది. అలాగే ఇది container log filesను ఎప్పుడూ చేర్చదు. Docker log fileను reclaim చేయగల objectగా పరిగణించదు. du ఒక directoryని docker system df చూపించే పరిమాణం కంటే చాలా పెద్దదిగా చూపిస్తే, దానికి log files కారణం. దాని గురించి కింద ఒక section ఉంది.

ప్రతి objectకు సంబంధించిన విభజన కోసం -v ను జోడించండి.

docker system df -v

ఇది summaryని ప్రతి object typeకు ఒక sectionగా విభజిస్తుంది. Image sectionలో SHARED SIZE మరియు UNIQUE SIZE columns జోడించబడతాయి. అందువల్ల ఒక image వాస్తవంగా ఎంత స్థలాన్ని ఉపయోగిస్తుందో చూడవచ్చు. Volume sectionలో LINKS count జోడించబడుతుంది. ఇది ఆ volumeకు అనుసంధానమైన containers సంఖ్య. LINKS ను గుర్తుంచుకోండి. దాని విలువ 0 అయితే ఏ container కూడా ఆ volumeను ఉపయోగించడం లేదు. ప్రతి volume prune command ప్రారంభమయ్యే పరిస్థితి ఇదే.

Dangling images మరియు unused images

ఈ రెండు పదాలు పరస్పరం మార్చి ఉపయోగించగలవిగా కనిపిస్తాయి. కానీ అవి ఒకే అర్థం కలిగినవి కావు. Objects వేర్వేరుగా ఉండటంవల్ల filters వేర్వేరుగా పనిచేస్తాయి.

Dangling image అంటే tag లేని image. ఇది <none> లో docker images గా కనిపిస్తుంది. ప్రతి rebuild సమయంలో ఇలాంటి image ఒకటి ఏర్పడుతుంది: docker build -t myapp:latest . `myapp:latest` tag ను కొత్త image కు తరలిస్తుంది. పాత image తన layers అన్నింటినీ ఉంచుకుంటుంది, కానీ దాని పేరు తొలగిపోతుంది. దాన్ని ఏదీ refer చేయదు. అది స్వయంచాలకంగా cleanup కూడా కాదు.

Unused image అంటే ప్రస్తుతం ఏ container refer చేయని ఏ image అయినా. గత నెలలో pull చేసిన postgres:16 ను running లేదా stopped containers ఏవీ refer చేయకపోతే, అది unused image అవుతుంది. కానీ అది dangling image కాదు.

docker image prune        # dangling images only
docker image prune -a     # every image no container refers to

రెండవ command ముందుగా confirmation అడుగుతుంది.

WARNING! This will remove all images without at least one container associated to them.
Are you sure you want to continue? [y/N]

ఆ prompt ను జాగ్రత్తగా చదవండి. "Associated to them" అంటే running లేదా stopped స్థితిలో ఉన్న existing container object అని అర్థం. మీరు docker compose down అమలు చేసి ఉంటే containers తొలగిపోయాయి. కాబట్టి ఆ services ఉపయోగించిన ప్రతి image ఇప్పుడు unused అవుతుంది. -a వాటన్నింటినీ తొలగిస్తుంది. తిరిగి పొందలేని data ఏదీ పోదు. కానీ తరువాతి docker compose up -d సమయంలో అవన్నీ మళ్లీ pull లేదా rebuild చేయాలి. చిన్న VPS లో దీనికి bandwidth మరియు build time ఖర్చవుతుంది. అందుకే ఏదైనా prune చేయడానికి ముందు docker compose down ఏవి తొలగిస్తుంది, stop ఏవి నడుస్తూనే ఉంచుతుంది అనేది తెలుసుకోవడం ఉపయోగకరం.

ఒక filter ఇటీవలి images ను పరిధి వెలుపల ఉంచుతుంది.

docker image prune -a --filter "until=240h"

ఇది 240 hours (10 days) కంటే ముందుగా సృష్టించిన unused images ను తొలగిస్తుంది. కొత్త images ను అలాగే ఉంచుతుంది. until విలువ 240h వంటి Go duration string ను లేదా 2026-08-01T00:00:00 వంటి absolute timestamp ను స్వీకరిస్తుంది.

Build cache అంటే ఏమిటి, అది ఎందుకు ఇంత పెద్దదిగా పెరుగుతుంది

Docker Engine 23.0 నుంచి docker build మరియు docker compose build కోసం Docker defaultగా ఉపయోగిస్తున్న builder BuildKit. ఇది అమలు చేసే ప్రతి Dockerfile లోని ప్రతి దశ ఫలితాన్ని cache చేస్తుంది. Classic overlay2 layoutలో ఈ cacheను /var/lib/docker/buildkit లో ఉంచుతుంది. రెండో build కొన్ని సెకన్లలో పూర్తవడానికి cache కారణం. కాబట్టి ఇది సరిగ్గా పనిచేస్తోంది. Docker Engine దీనిపై defaultగా garbage collection అమలు చేస్తుంది. 60 రోజులుగా ఎవరూ ఉపయోగించని cache తొలగించబడుతుంది. మిగిలిన cacheను Docker Engine disk పరిమాణం ఆధారంగా నిర్ణయించే పరిమితులను దాటిన తర్వాత మాత్రమే trim చేస్తుంది. చిన్న VPSలో disk ఇప్పటికే దాదాపు పూర్తిగా నిండినప్పుడు ఇది జరగవచ్చు. ప్రతి సారి మారే COPY stepతో అదే imageను 50 సార్లు build చేస్తే, collection ప్రారంభమయ్యే వరకు 50 layer సముదాయాలు అలాగే ఉంటాయి.

Build cacheను docker image prune చూడదు. ఇది స్వంత command కలిగిన ప్రత్యేక object type.

docker builder prune                        # dangling cache
docker builder prune -a                     # all unused cache
docker builder prune --filter until=168h    # cache untouched for 7 days

వీటిలో ఏదీ మీ imagesను లేదా dataను తాకదు. Build cacheను clear చేయడం వల్ల కలిగే ఏకైక ప్రభావం, తరువాతి build ఒక్కసారి నెమ్మదిగా నడవడం. Imagesను తరచుగా rebuild చేసే VPSలో Build Cache సాధారణంగా docker system df లో అతిపెద్ద వరుసగా ఉంటుంది. అందువల్ల తొలగించడానికి ఇది పెద్దవాటిలో అత్యంత సురక్షితమైనది.

భద్రత నుంచి విధ్వంసక ప్రభావం వరకు క్రమబద్ధీకరించిన prune commands

df -h / మళ్లీ సక్రమంగా కనిపించే వరకు ఈ జాబితాలోని commands ను క్రమంగా అమలు చేసి, వెంటనే ఆపండి. ప్రతి command పూర్తయ్యే సమయంలో ఒక Total reclaimed space: line ను ముద్రిస్తుంది.

  1. docker container prune ఆపివేసిన containers ను తొలగిస్తుంది. వాటి writable layers కూడా తొలగిపోతాయి. అందువల్ల volume వెలుపల container రాసిన ఏదైనా డేటా container తో పాటు తొలగిపోతుంది. Volumes ప్రభావితం కావు.
  2. docker image prune dangling images ను మాత్రమే తొలగిస్తుంది. అందుబాటులో ఉన్న image commands లో ఇది అత్యంత సురక్షితమైనది.
  3. docker builder prune dangling build cache ను తొలగిస్తుంది. దీని ప్రభావం ఒకసారి build నెమ్మదిగా పూర్తవడం మాత్రమే.
  4. docker image prune -a ఏ container కూడా సూచించని ప్రతి image ను తొలగిస్తుంది. తరువాత image ను మళ్లీ pull చేయాలి లేదా rebuild చేయాలి.
  5. docker system prune మొదటి మూడు చర్యలను ఒకేసారి చేసి, unused networks ను కూడా తొలగిస్తుంది.
  6. docker volume prune unused anonymous volumes ను తొలగిస్తుంది.
  7. docker volume prune -a named volumes తో సహా unused volumes ను తొలగిస్తుంది. Databases ను తొలగించేది ఇదే command.

docker system prune అమలు కావడానికి ముందు తన పరిధిని స్వయంగా తెలియజేస్తుంది.

WARNING! This will remove:
        - all stopped containers
        - all networks not used by at least one container
        - all dangling images
        - unused build cache
Are you sure you want to continue? [y/N]

Volumes ను ఉద్దేశపూర్వకంగానే ఆ జాబితాలో చేర్చలేదు. --volumes జోడిస్తే anonymous volumes కూడా పరిధిలోకి వస్తాయి. -a జోడిస్తే image దశ dangling images నుంచి ప్రతి unused image వరకు విస్తరిస్తుంది. Production host పై పూర్తి docker system prune -a --volumes -f అమలు చేయడం ద్వారా స్థలం ఖాళీ చేయడానికి ప్రయత్నిస్తూ డేటాను కోల్పోయే పరిస్థితి ఏర్పడుతుంది.

వాల్యూమ్‌లను prune చేయడం వల్ల మీ database ఎందుకు తొలగిపోతుంది

ఈ విభాగాన్ని రెండుసార్లు చదవండి.

ఏ container కూడా attach అయి లేకపోతే ఆ volume unused గా పరిగణించబడుతుంది. పరీక్ష అంతే. ఆ volume ఖాళీగా ఉందా, compose file లో ఇప్పటికీ అది declare చేయబడిందా, లేదా మీ database యొక్క ఏకైక copy అందులో ఉందా అనే విషయాలను Docker పరిశీలించదు. LINKS 0 లోని docker system df -v అంటే unused అని అర్థం. మీరు జోడించిన label filter మినహాయించకపోతే, docker volume prune -a ప్రతి unused volume ను తొలగించదగినదిగా పరిగణిస్తుంది.

ఇప్పుడు సాధారణంగా చేసే రెండు చర్యలను వరుసగా చూద్దాం. Stack ను సక్రమంగా restart చేయడానికి మీరు docker compose down అమలు చేస్తారు. ఇది containers ను తొలగించి, named volumes ను అలాగే ఉంచుతుంది. ఆ command documentation ప్రకారం చేయాల్సింది అదే. ఇప్పుడు మీ Postgres volume ఏ container కు attach అయి ఉండదు. పది నిమిషాల తరువాత స్థలాన్ని ఖాళీ చేయడానికి docker volume prune -a అమలు చేస్తారు, database తొలగిపోతుంది. రెండు commands సరిగ్గానే పనిచేశాయి. కానీ ఆ క్రమం data ను నాశనం చేసింది.

Docker Engine 23.0 (API version 1.42) నుంచి సాధారణ command గతంలోకంటే పరిమితంగా పనిచేస్తుంది.

WARNING! This will remove anonymous local volumes not used by at least one container.

Anonymous volume అంటే Docker మీ కోసం సృష్టించిన volume. సాధారణంగా image లో VOLUME declare అయి ఉండి, మీరు దానికి పేరు ఇవ్వనప్పుడు ఇది ఏర్పడుతుంది. మీరు ఉద్దేశపూర్వకంగా ఉంచాలని కోరని data ఈ volumes లో సాధారణంగా ఉంటుంది. మీరు compose file లో రాసిన named volume, -a జోడించినప్పుడు మాత్రమే తొలగించబడుతుంది. పాత Docker versions సాధారణ command తో రెండింటినీ తొలగించేవి. కాబట్టి upgrade చేసిన server లో ఏర్పడిన పాత అలవాట్లను నమ్మవద్దు. ఈ తేడా అర్థం కావాలంటే ముందుగా named volumes మరియు bind mounts ఎలా భిన్నంగా ఉంటాయో తెలుసుకోవాలి. ఎందుకంటే bind mount అనేది Docker volume కాదు, అందువల్ల ఏ prune command కూడా దాన్ని తొలగించదు.

తొలగించే ముందు పరిశీలించండి. మీరు తనిఖీ చేస్తున్న volume name స్థానంలో myapp_pgdata ను మార్చండి.

docker volume ls -f dangling=true
docker volume inspect myapp_pgdata
sudo ls -la /var/lib/docker/volumes/myapp_pgdata/_data

Volume పై ఉన్న dangling=true filter అంటే unreferenced అని, empty అని కాదు. _data ను list చేస్తే అందులో నిజంగా ఏముందో తెలుస్తుంది. అక్కడ pgdata లేదా mysql directory కనిపిస్తే ఆపి, ముందుకు వెళ్లే ముందు ఒక copy తీసుకోండి. అదే విధ్వంసం docker compose down -v ద్వారా కూడా జరుగుతుంది. ఇది compose file declare చేసిన named volumes ను తొలగిస్తుంది. external గా గుర్తించిన వాటిని మాత్రమే మినహాయిస్తుంది. ముందుగా మీ అనుమతి కూడా అడగదు.

Docker host పై rebuild ద్వారా మళ్లీ సృష్టించలేని ఏకైక విషయం volume. అందుకే volume data ను server వెలుపల అమలయ్యే restic backup లో ఉంచాలి. తప్పుగా ఇచ్చిన flag కూడా ఆ backup కు చేరుకోలేడు.

కంటైనర్ log files ను prune చేసినా స్థలం ఎందుకు ఖాళీ కాకపోవచ్చు

మీరు అన్నింటినీ prune చేశారు. docker system df లో reclaim చేయగల స్థలం దాదాపు ఏమీ కనిపించడం లేదు. అయినా disk నిండే ఉంది. Logs ను పరిశీలించండి.

sudo find /var/lib/docker/containers -name '*-json.log' -exec du -h {} + | sort -h | tail -10

ప్రతి container తన standard output మరియు standard error ను /var/lib/docker/containers/ లోని JSON file లో రాస్తుంది. Default install లో max-size unset గా ఉంటుంది. అంటే దీనికి పరిమితి ఉండదు. Crash loop లో చిక్కుకున్న ఒకే container partition నిండే వరకు రాస్తూనే ఉండవచ్చు. ఈ files ను ఏ prune command కూడా తొలగించదు. వాటిని సృష్టిస్తున్న containers running లో ఉండటం వల్ల, నిర్వచనం ప్రకారం అవి prunable కావు.

File ను delete చేయవద్దు. Open log file పై rm అమలు చేసినా ఏ స్థలమూ ఖాళీ కాదు. Docker daemon ఆ file descriptor ను ఇంకా open గా ఉంచుతుంది. ఆ handle close అయ్యే వరకు kernel ఆ blocks ను allocated గానే ఉంచుతుంది. df లో పరిమాణం ఏమాత్రం తగ్గదు. దాని బదులుగా truncate చేయండి. అప్పుడు అదే inode కొనసాగుతుంది మరియు daemon writing కొనసాగించగలదు.

sudo find /var/lib/docker/containers -name '*-json.log' -exec truncate -s 0 {} +
df -h /

ఇది తాత్కాలిక పరిష్కారం మాత్రమే. ఇప్పుడు ఆ containers కోసం docker logs ఏ output ఇవ్వదు. అయితే files వెంటనే మళ్లీ పెరగడం ప్రారంభిస్తాయి. అసలు పరిష్కారం log rotation. అది తదుపరి section లో ఉంది.

ముందు మరియు తర్వాత పరిమాణాన్ని ప్రతిసారీ కొలవండి

prune ఏమి చేసిందో ఎప్పుడూ ఊహించవద్దు. ముందుగా ఒక కొలత తీసుకోండి, ఒక command అమలు చేయండి, తర్వాత మరో కొలత తీసుకోండి.

df -h /
docker system df
docker builder prune -f --filter until=168h
docker image prune -f
docker system df
df -h /

రెండు df outputs ను పోల్చండి. మీ server సేవలను కొనసాగిస్తుందా లేదా నిర్ణయించే ఏకైక సంఖ్య అదే. docker system df లో ఏ row వాస్తవంగా మారిందో తెలుస్తుంది. ప్రతి prune తన స్వంత Total reclaimed space: విలువను కూడా ముద్రిస్తుంది.

df మారకపోయినా docker system df లో space freed అని కనిపిస్తే, తొలగించిన blocks ను ఒక open file handle పట్టుకుని ఉంది. పైన వివరించిన log file సమస్య ఇదే. రెండూ మారి, disk ఒక రోజులో మళ్లీ నిండిపోతే, ఇది cleanup సమస్య కాదు; growth సమస్య. దీనికి rotation తో పాటు scheduled job అవసరం.

మళ్లీ డిస్క్ నిండిపోకుండా ఎలా ఆపాలి

లాగ్ పరిమాణాన్ని పరిమితం చేయండి. /etc/docker/daemon.json ను సృష్టించండి లేదా సవరించండి.

{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
  }
}

Restart తర్వాత సృష్టించే ప్రతి container కు గరిష్ఠంగా 30 MB logs ఉండేలా ఇది పరిమితం చేస్తుంది. log-opts లోని ప్రతి విలువ string అయి ఉండాలి. Restart చేయడానికి ముందు file ను parse చేయగలదో తనిఖీ చేయండి. తప్పుగా రూపొందిన daemon.json daemon ప్రారంభం కాకుండా ఆపుతుంది. దాంతో అన్ని containers కూడా ఆగిపోతాయి.

python3 -m json.tool /etc/docker/daemon.json
sudo systemctl restart docker
docker info | grep -i 'logging driver'

ఇప్పుడు docker info Logging Driver: json-file అని చూపించాలి. Restart తర్వాత సృష్టించిన container లోని docker inspect యొక్క LogConfig section లో పరిమితులు కనిపిస్తాయి. ముఖ్యమైన విషయం ఏమిటంటే, ఈ setting కొత్త containers కు మాత్రమే వర్తిస్తుంది. ఇప్పటికే ఉన్న containers అవి నిర్మించబడినప్పుడు పొందిన configuration నే ఉంచుకుంటాయి. అందువల్ల వాటిని మళ్లీ సృష్టించండి.

docker compose up -d --force-recreate

Compose file లో ప్రతి service కు ఇదే పరిమితిని విడిగా ఇవ్వవచ్చు. ఒక service మాత్రమే ఎక్కువ logs సృష్టిస్తే, దానికి స్వంత పరిమితి ఇవ్వడానికి ఇది మెరుగైన ఎంపిక.

services:
  app:
    logging:
      driver: json-file
      options:
        max-size: "10m"
        max-file: "3"

పరిమిత పరిధిలో prune schedule చేయండి. Dangling images మరియు పాత build cache కు మాత్రమే పరిమితం చేసి, వారానికి ఒకసారి అమలు చేయండి. Scheduled job లో ఎప్పుడూ -a లేదా --volumes ఉంచవద్దు. Stack down లో ఉన్న సమయంలో job అమలైతే, ఆ stack కు చెందిన images తొలగిపోతాయి. --volumes తో అది మీ data పై కూడా చర్య ప్రారంభిస్తుంది.

sudo tee /etc/cron.weekly/docker-prune >/dev/null <<'EOF'
#!/bin/sh
docker image prune -f
docker builder prune -f --filter until=168h
EOF
sudo chmod +x /etc/cron.weekly/docker-prune
sudo /etc/cron.weekly/docker-prune

చివరి line script ను ముందుగా చేతితో ఒకసారి అమలు చేస్తుంది. అందువల్ల unattended గా అమలు కావడానికి ముందే దాని output ను చూడవచ్చు. File executable అయి ఉండాలి. దాని పేరు dot ను కలిగి ఉండకూడదు. ఎందుకంటే run-parts executable కాని files ను, extension ఉన్న files ను దాటవేస్తుంది.

ఖాళీ స్థలంపై alert ఏర్పాటు చేయండి. డిస్క్ నిండిన తర్వాత మీరు అమలు చేసే prune recovery చర్య మాత్రమే. 80 percent వద్ద వచ్చే alert prevention చర్య.

usage=$(df --output=pcent / | tr -dc '0-9')
[ "$usage" -ge 80 ] && echo "root filesystem at ${usage} percent full"

మీరు ఇప్పటికే ఉపయోగిస్తున్న notifier తో దీన్ని cron లో ఉంచండి. Free space మొత్తం పరిస్థితిలో సగం మాత్రమే. అందువల్ల ఈ alert ను మీ VPS లో disk health monitoring తో కలిపి ఉపయోగించండి. Failing disk మరియు full disk రెండూ మీ containers ను ఆపుతాయి. అయితే వాటికి వేర్వేరు పరిష్కారాలు అవసరం.

పైనివన్నీ data root /var/lib/docker వద్ద ఉన్న standard install ను ఆధారంగా చేసుకున్నాయి. daemon.json లోని data-root key ఉపయోగించి దాన్ని మార్చి ఉంటే, ప్రతి command లో మీ path ను ఉపయోగించండి. containerd image store లో data-root image మరియు container data ను /var/lib/containerd లోకి మార్చదు. ఆ location ను /etc/containerd/config.toml లోని root నిర్ణయిస్తుంది. కొత్త server ను సిద్ధం చేసేటప్పుడు ఈ layout ను సరిగ్గా ఏర్పాటు చేయడం VPS లో Docker setup చేయడం లో భాగం. 40 GB containers తప్పు partition పై చేరిన తర్వాత నిర్ణయించడంకన్నా, ముందుగానే నిర్ణయించడం చాలా సులభం.

FAQ

docker system prune నా volumes ను తొలగిస్తుందా?

లేదు. సాధారణ command stopped containers, unused networks, dangling images మరియు unused build cache ను తొలగిస్తుంది. దాని confirmation prompt లో కూడా ఇదే జాబితా ఉంటుంది. --volumes ను జోడించినప్పుడు మాత్రమే volumes కూడా పరిధిలోకి వస్తాయి. Docker Engine 23.0 నుంచి ఆ flag named volumes కు కాకుండా anonymous volumes కు వర్తిస్తుంది. Named volumes ను docker volume prune -a మరియు docker compose down -v తొలగిస్తాయి. ఈ రెండు commands తోనే జాగ్రత్తగా ఉండాలి.

docker prune అమలు చేసిన తర్వాత కూడా నా disk ఎందుకు full గానే ఉంది?

సాధారణంగా రెండు కారణాలు ఉంటాయి. మొదటిది /var/lib/docker/containers/ కింద ఉన్న container log files. ఏ prune command కూడా వీటిని తాకదు. max-size ను సెట్ చేసే వరకు ఇవి పరిమితి లేకుండా పెరుగుతాయి. రెండవది, ఒక process ఇంకా open గా ఉంచుకున్న deleted file. Container నడుస్తున్నప్పుడు rm తో log ను తొలగిస్తే, daemon file descriptor ను ఉంచుకుంటుంది. Kernel blocks ను release చేయదు. అందువల్ల df లో మార్పు కనిపించదు. మీ పరిస్థితి ఏదో తెలుసుకోవడానికి sudo du -xh --max-depth=1 /var/lib/docker ను docker system df తో పోల్చండి.

docker image prune మరియు docker image prune -a మధ్య తేడా ఏమిటి?

సాధారణ command dangling images ను మాత్రమే తొలగిస్తుంది. అంటే వాటి tag కోల్పోయిన images. ఇవి దాదాపు ఎల్లప్పుడూ rebuild కారణంగా ఏర్పడతాయి. -a రూపం ఏ existing container కూడా సూచించని ప్రతి image ను తొలగిస్తుంది. మీరు ఉద్దేశపూర్వకంగా pull చేసిన tagged images కూడా ఇందులో ఉంటాయి. docker compose down తర్వాత containers తొలగించబడతాయి. అందువల్ల -a ఆ stack కు చెందిన images ను కూడా తొలగిస్తుంది. ఏదీ శాశ్వతంగా కోల్పోరు. తదుపరి start సమయంలో అవి మళ్లీ pull లేదా rebuild అవుతాయి. అయితే నెమ్మదైన link పై దీనికి ఎక్కువ సమయం పడుతుంది.

Docker logs వల్ల disk full కాకుండా ఎలా ఆపాలి?

/etc/docker/daemon.json లోని log-opts కింద max-size మరియు max-file ను సెట్ చేయండి. తరువాత sudo systemctl restart docker తో daemon ను restart చేయండి. ఈ setting restart తర్వాత సృష్టించే containers కు మాత్రమే వర్తిస్తుంది. అందువల్ల నడుస్తున్న containers ను docker compose up -d --force-recreate తో recreate చేయండి. Compose file లోని logging key కింద ప్రతి service కు ఇదే రెండు options ను సెట్ చేయవచ్చు. మిగిలిన services కంటే ఒక service చాలా ఎక్కువ logs రాసే సందర్భంలో ఇది ఉపయోగకరం.

cron job లో docker system prune అమలు చేయడం సురక్షితమేనా?

ప్రతి stack నిరంతరం నడుస్తున్న host పై సాధారణ docker system prune -f సురక్షితం. అయితే ఇది stopped containers ను తొలగిస్తుంది. ఉద్దేశపూర్వకంగా ఆపి, తరువాత మళ్లీ start చేయాలనుకున్న container కూడా తొలగించబడుతుంది. షెడ్యూల్ చేయడానికి మరింత సురక్షితమైన job docker image prune -f మరియు docker builder prune -f --filter until=168h. ఇవి వేగంగా పెరిగే రెండు అంశాలను తొలగిస్తాయి. Volume ను మాత్రం తాకవు. -a లేదా --volumes ను ఎప్పుడూ schedule చేయవద్దు.

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