కంటైనర్ లాగ్లు మరియు వాటిని ఎలా కోల్పోకూడదు

సేవ డౌన్ అయినప్పుడు, లాగ్ మాత్రమే నిజమైన ఆధారం. డిఫాల్ట్‌గా Docker దాన్ని కంటైనర్ పక్కనే ఉన్న ఫైల్‌లో రాస్తుంది మరియు దాని పరిమాణానికి ఎటువంటి పరిమితి పెట్టదు: ఎక్కువగా రాసే యాప్లికేషన్ ఒక వారంలో మొత్తం డిస్క్‌ను నింపేయగలదు.

ఎలా చదవాలి

docker logs -f --tail 100 <container>
docker compose logs -f app
docker compose logs --since 30m --timestamps app
docker logs <container> 2>&1 | grep -i error | tail -50

గుర్తుంచుకోవాల్సిన విషయం: Docker అనేది యాప్లికేషన్ స్టాండర్డ్ అవుట్‌పుట్ మరియు స్టాండర్డ్ ఎర్రర్‌కు రాసేదాన్ని చూపిస్తుంది. అది కంటైనర్ లోపల తన సొంత ఫైల్‌కు రాస్తే, docker logs ఏమీ చూపదు — మీరు లాగ్‌ను లోపల వెతకాలి లేదా అవుట్‌పుట్‌ను రీడైరెక్ట్ చేయాలి.

docker compose exec app ls -la /var/log

ఇప్పుడే పరిమాణానికి పరిమితి పెట్టండి

అన్ని కంటైనర్లకు గ్లోబల్ సెట్టింగ్ /etc/docker/daemon.json:

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

sudo systemctl restart docker

ఈ సెట్టింగ్ రీస్టార్ట్ తర్వాత సృష్టించిన కంటైనర్లకు వర్తిస్తుంది. నడుస్తున్న వాటిని తిరిగి సృష్టించాలి. ఒకే సేవ కోసం, ఇదే విషయం Compose లోకి వెళ్తుంది:

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

ఫలితం: అపరిమిత పెరుగుదలకు బదులుగా ఒక సేవకు గరిష్ఠంగా 60 MB.

అది మిమ్మల్ని ఆశ్చర్యపరిచే ముందే ప్రస్తుత పరిమాణాన్ని తనిఖీ చేయండి: sudo du -sh /var/lib/docker/containers/*/*-json.log | sort -h | tail. నడుస్తున్న ఫైల్‌ను rm తో తగ్గించలేరు — Docker డిస్క్రిప్టర్‌ను పట్టుకుని ఉన్నంతవరకు స్థలం విడుదల కాదు. సరైన మార్గం: కంటైనర్‌ను తిరిగి సృష్టించండి లేదా sudo truncate -s 0 <file>.

కంటైనర్ తర్వాత కూడా లాగ్‌లు నిలిచేలా చేయండి

లాగ్ ఫైల్ కంటైనర్‌తో పాటే తొలగించబడుతుంది. చరిత్ర ముఖ్యమైతే, దాన్ని సిస్టమ్ జర్నల్‌కు అప్పగించండి:

logging:
  driver: journald
  options:
    tag: "myapp"

journalctl -t myapp -n 200 --since today
journalctl -t myapp -p err --since "2 days ago"

journald రికార్డులను తనంతట తానే రొటేట్ చేస్తుంది మరియు /etc/systemd/journald.conf లోని SystemMaxUse సెట్టింగ్ ద్వారా పరిమితం చేయబడుతుంది. అది ఎంత స్థలం తీసుకుంటుందో తనిఖీ చేయడానికి: journalctl --disk-usage.

ఒకేసారి అనేక సేవల కోసం అన్నింటినీ ఒకే చోట సేకరించడం మరింత సౌకర్యవంతం — ఉదాహరణకు, రికార్డులను రోజువారీగా ఫైల్‌లలో నిల్వ చేసే ప్రత్యేక కలెక్టర్ కంటైనర్‌తో. కానీ journald తో ప్రారంభించండి: అది ఇప్పటికే ఉంది మరియు ఏమీ ఖర్చు కాదు.

అవుటేజీని డీబగ్ చేసేటప్పుడు ఏమి చూడాలి

1. క్రాష్‌కు ముందు చివరి 200 లైన్లు: docker logs --tail 200 <container>.
2. ఎగ్జిట్ కోడ్: docker inspect -f '{{.State.ExitCode}} {{.State.OOMKilled}}' <container>. కోడ్ 137 మరియు OOMKilled లో true అంటే మెమరీ అయిపోవడంతో కెర్నల్ ప్రాసెస్‌ను చంపిందని అర్థం — రిసోర్స్ పరిమితులు చూడండి.
3. మెషీన్ యొక్క సిస్టమ్ లాగ్: sudo dmesg -T | tail -50 అవుట్-ఆఫ్-మెమరీ కిల్స్ మరియు డిస్క్ ఎర్రర్లను చూపుతుంది.

సాధారణ తప్పులు

• లాగ్‌లతో డిస్క్ నిండిపోయి ప్రతి సేవ డౌన్ అయింది. Docker ఇన్‌స్టాల్ చేసిన వెంటనే పరిమాణానికి పరిమితి పెట్టడం తప్పనిసరి.
• ఇప్పటికే తొలగించిన కంటైనర్ లాగ్‌ను చూడటం. docker compose down తర్వాత అది పోతుంది. రికార్డులను ముందుగానే journald లో సేకరించండి.
• లాగ్‌లో సీక్రెట్‌లు. యాప్లికేషన్లు పాస్‌వర్డ్‌లతో కూడిన కనెక్షన్ స్ట్రింగ్‌లను ముద్రించడాన్ని ఇష్టపడతాయి. మెషీన్‌కు యాక్సెస్ ఉన్న ఎవరైనా లాగ్‌ను చదవగలరు.
• టెక్స్ట్ కన్సోల్‌లో ఎర్రర్ కోసం వెతకడం. అది ఎప్పుడూ 80×24 మరియు పొడవైన లైన్లు కత్తిరించబడతాయి. లాగ్‌లు చదవడానికి SSH లేదా “Screen” కన్సోల్ మరింత సౌకర్యవంతం.