డౌన్‌టైమ్ లేకుండా కంటైనర్‌లను అప్‌డేట్ చేయడం

కంటైనర్‌ను అప్‌డేట్ చేయడం అంటే “కొత్త ఇమేజ్‌ను pull చేయడం” కాదు — “నడుస్తున్న వెర్షన్‌ను కొత్త దానితో భర్తీ చేయడం, అవసరమైతే వెనక్కి తిప్పగలగడం.” ఈ తేడా ఒక్కసారే కనిపిస్తుంది: కొత్త వెర్షన్ స్టార్ట్ కాకపోయినప్పుడు.

పనిచేసే ప్రక్రియ

cd /opt/myapp
docker compose pull
docker compose up -d
docker compose ps
docker compose logs -f --tail 100

Compose ఇమేజ్ మారిన సర్వీసులను మాత్రమే మళ్లీ సృష్టిస్తుంది, మిగిలినవి అలాగే ఉంచుతుంది. కంటైనర్ రీస్టార్ట్ అవ్వడానికి పట్టే కొన్ని సెకన్లే డౌన్‌టైమ్.

కానీ ఇది చేయడానికి ముందు రెండు షరతులు తీరాలి.

మొదటిది: వెర్షన్‌లు పిన్ చేయబడి ఉండాలి. ఫైల్‌లో postgres:17.2 అని ఉండాలి, postgres:latest కాదు. లేకపోతే ఒకరోజు pull డేటా ఫార్మాట్‌ను మార్చేసే మేజర్ వెర్షన్‌ను తెచ్చి ఇస్తుంది, అప్పుడు రోల్‌బ్యాక్ అసాధ్యమవుతుంది.

రెండవది: బ్యాకప్ తాజాగా ఉండాలి. డేటాబేస్‌ను పాడుచేసే అప్‌డేట్ దాన్ని తిరిగి పునరుద్ధరించలేని విధంగా పాడుచేస్తుంది. మేజర్ వెర్షన్ మార్పుకు ముందు డంప్ తీసుకోండి — ఏమి బ్యాకప్ చేయాలి చూడండి.

విరామం లేకుండా భర్తీ చేయడం

రివర్స్ ప్రాక్సీ వెనుక ఉన్న వెబ్ సర్వీస్ కోసం, కంటైనర్‌కు హెల్త్ చెక్ ఉంటే డౌన్‌టైమ్ దాదాపు సున్నాకు పడిపోతుంది: సిద్ధంగా ఉన్న ఇన్‌స్టాన్స్‌కు మాత్రమే ప్రాక్సీ రిక్వెస్ట్‌లు పంపడం మొదలుపెడుతుంది.

services:
  app:
    image: ghcr.io/example/app:1.5.0
    healthcheck:
      test: ["CMD", "curl", "-fsS", "http://localhost:8080/health"]
      interval: 5s
      timeout: 3s
      retries: 6
      start_period: 20s

docker inspect -f '{{.State.Health.Status}}' <container>

హెల్త్ చెక్ లేకపోతే, ప్రాసెస్ స్టార్ట్ అవ్వగానే కంటైనర్ సిద్ధమైందని Compose భావిస్తుంది — అప్లికేషన్ ఇంకా దాని సెట్టింగ్‌లను చదువుతూ, మైగ్రేషన్‌లు అమలు చేస్తున్న సమయంలోనే.

కొత్త వెర్షన్ కనీసం ఒక గంట నడిచే వరకు పాత ఇమేజ్‌ను తొలగించవద్దు. రోల్‌బ్యాక్ అంటే image: ...:1.4.2ను పునరుద్ధరించి docker compose up -d నడపడం, కానీ పాత ఇమేజ్ ఇంకా డిస్క్‌లో ఉన్నంత వరకే. అప్‌డేట్ వెంటనే docker image prune -a నడపడం ఆ అవకాశాన్ని మీ నుండి లాక్కుంటుంది.

రోల్‌బ్యాక్

sed -i 's|app:1.5.0|app:1.4.2|' compose.yaml
docker compose up -d app
docker compose logs -f --tail 50 app

కొత్త వెర్షన్ ఇప్పటికే డేటాబేస్ స్కీమాను మార్చేసి ఉంటే, ఇమేజ్‌ను మాత్రమే వెనక్కి తిప్పడం సరిపోదు — బ్యాకప్ నుండి పునరుద్ధరించుకోవాల్సి ఉంటుంది. అందుకే మేజర్ అప్‌డేట్‌లు ప్రశాంతమైన సమయంలో, ధృవీకరించిన బ్యాకప్‌తో చేస్తారు: రీస్టోర్ డ్రిల్ చూడండి.

ఆటోమేషన్: జాగ్రత్తగా ఉండండి

Watchtower తనంతట తానే కంటైనర్‌లను అప్‌డేట్ చేయగలదు. ఇంటి సర్వీసులకు అది సౌకర్యం; ప్రొడక్షన్‌కు అది రిస్క్: అప్‌డేట్ రాత్రి వచ్చి, డేటాబేస్‌ను పాడుచేస్తుంది, ఎవరూ గమనించరు. సహేతుకమైన రాజీ నోటిఫికేషన్‌లు మాత్రమే:

services:
  watchtower:
    image: containrrr/watchtower
    restart: unless-stopped
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    command: --monitor-only --schedule "0 0 6 * * *"

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

మెషీన్‌ను రీబూట్ చేయడం

సిస్టమ్ ప్యాకేజీలు కంటైనర్‌ల నుండి విడిగా అప్‌డేట్ అవుతాయి. కర్నెల్ అప్‌డేట్ తర్వాత రీబూట్ అవసరం, restart: unless-stopped ఉన్న కంటైనర్‌లు తమంతట తామే తిరిగి పైకి వస్తాయి. దీన్ని ముందుగానే పరీక్షించండి — ఒక ఇన్సిడెంట్ సమయంలో కాదు, ప్రశాంతమైన సమయంలో sudo rebootతో. సిస్టమ్‌లో qemu-guest-agent ఇన్‌స్టాల్ అయి ఉన్నంత వరకు ప్యానెల్ నుండి సాఫ్ట్ రీబూట్ పనిచేస్తుంది.

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

• up -d లేకుండా pull. కొత్త ఇమేజ్ డౌన్‌లోడ్ అవుతుంది, కానీ పాత కంటైనర్ ఇంకా నడుస్తూనే ఉంటుంది.
• డిస్క్ పాత ఇమేజ్‌లతో నిండిపోవడం. నెలకు ఒకసారి docker image prune నడపండి — కానీ అప్‌డేట్ వెంటనే కాదు. డిస్క్ స్పేస్ చూడండి.
• అన్నింటినీ ఒకేసారి అప్‌డేట్ చేయడం. ఏదో పాడవుతుంది — ఏదో మీకు తెలియదు. ఒక్కోసారి ఒక సర్వీస్‌ను మాత్రమే అప్‌డేట్ చేయండి.
• మీరు రిలీజ్ నోట్స్ చదవకపోవడం. మేజర్ వెర్షన్ మార్పు తర్వాత ఫెయిల్ అవ్వడానికి అత్యంత సాధారణ కారణం ఇన్‌కంపాటిబుల్ కాన్ఫిగ్ ఫైల్; సాధారణ Docker సమస్యలులో వివరణ చూడండి.