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

డేటాబేస్ Docker లో నడపాలా లేదా హోస్ట్ మెషీన్ లోనా?

Postgres, MySQL, MongoDB వంటి డేటాబేస్‌లను Docker కంటైనర్లలో నడపడం సురక్షితమేనా? వాల్యూమ్స్, వెర్షన్ అప్‌గ్రేడ్లు మరియు బ్యాకప్ నిర్వహణలో తీసుకోవాల్సిన జాగ్రత్తల గురించి తెలుసుకోండి.

డేటాబేస్ Docker లో నడపాలా లేదా హోస్ట్ (host) పై నడపాలా?

డేటాబేస్‌ను Docker లోనే నడపండి. ఒక VPS పై ఒక అప్లికేషన్ స్టాక్ కోసం, కంటైనరైజ్డ్ PostgreSQL, MySQL, MongoDB లేదా Redis వాడటం సాధారణ ప్రొడక్షన్ ఎంపిక. దీనిపై జరిగే వాదనలు సాధారణంగా తప్పుదోవ పట్టిస్తాయి. కంటైనర్ అనేది Linux ప్రాసెస్ మాత్రమే, దీని చుట్టూ namespaces మరియు cgroups ఉంటాయి; ఇది వర్చువల్ మెషీన్ కాదు, కాబట్టి డేటాబేస్‌కు మరియు డిస్క్‌కు మధ్య ఎటువంటి hypervisor ఉండదు. Bind mount లేదా local named volume వాడినప్పుడు, రీడ్ మరియు రైట్ ఆపరేషన్లు నేరుగా హోస్ట్ ఫైల్‌సిస్టమ్‌పైనే జరుగుతాయి, ఇది ప్యాకేజీ ఇన్‌స్టాలేషన్ వాడే పద్ధతికి సమానం.

నిజమైన సవాలు నిర్వహణకు సంబంధించినది. ఈ సెటప్ బాగుంటుందా లేదా విపత్తుగా మారుతుందా అనేది నాలుగు అంశాలపై ఆధారపడి ఉంటుంది: డేటా ఎక్కడ నిల్వ చేయబడింది, ఆ డైరెక్టరీకి యజమాని ఎవరు, మేజర్ వెర్షన్ అప్‌గ్రేడ్ ప్రక్రియ ఎలా ఉంటుంది, మరియు మీరు ఎప్పుడైనా బ్యాకప్‌ను రీస్టోర్ చేశారా? వీటిని సరిగ్గా నిర్వహిస్తే, కంటైనర్ అనేది ఒక చిన్న విషయం మాత్రమే. వీటిని విస్మరిస్తే, మీరు కంటైనర్‌నే నిందించాల్సి వస్తుంది.

ఏ సర్వర్ డేటాబేస్ కైనా ఇదే నిర్ణయం వర్తిస్తుంది. కింద ఉన్న ఉదాహరణలు PostgreSQL, MySQL, MongoDB మరియు Redis లపై ఆధారపడి ఉంటాయి. ఉత్పత్తికి సంబంధించిన ప్రత్యేక వ్యత్యాసాలు అవసరమైన చోట పేర్కొనబడ్డాయి.

కంటైనర్ వాస్తవంగా మార్చేది ఏమిటి

మీరు ఒకదాన్ని mount చేసినంతకాలం storage path మారదు. అదే kernel, అదే page cache, అదే filesystem.

ఒక నిజమైన performance సమస్య ఉంది. అది ఏదీ mount చేయని సందర్భంలో వస్తుంది. volume లేకపోతే data directory image పై అమర్చిన overlay filesystem అయిన container యొక్క writable layer లోకి వెళ్తుంది. అక్కడ writes నెమ్మదిగా ఉంటాయి. Container తొలగించినప్పుడు మొత్తం layer కూడా తొలగిపోతుంది. “ఈ ఉదయం నా database ఖాళీగా ఉంది” అనే సమస్యకు కారణం ఇదే.

వాస్తవంగా మారేవి:

  • Lifecycle. docker compose down container ను తొలగిస్తుంది. volume లో లేని ఏదైనా దానితో పాటు తొలగిపోతుంది.
  • Version. Image tag version ను సూచిస్తుంది. తదుపరి docker compose pull ను దాటి నిలిచే apt upgrade database container లో ఉండదు.
  • Memory accounting. cgroup limit kernel అమలు చేసే కఠిన పరిమితి. చాలా database defaults తమ పరిమాణాన్ని దానికి అనుగుణంగా స్వయంచాలకంగా నిర్ణయించవు. MySQL 9.3 లేదా తదుపరి సంస్కరణలు కొన్ని settings కోసం ఆ limit ను చదువుతాయి. MongoDB తన WiredTiger cache కోసం అలా చేయడానికి ప్రయత్నిస్తుంది. అయితే కొన్ని సందర్భాల్లో అలా చేయకపోవచ్చని దాని documentation హెచ్చరిస్తుంది. PostgreSQL మరియు Redis అలా చేయవు.
  • User. Process container లో numeric user id గా నడుస్తుంది. ఆ user కు మీ host పై ఏదీ సొంతంగా ఉండకపోవచ్చు.

డేటా ఎక్కడ నిల్వ ఉందో అన్నదే ప్రతిదీ నిర్ణయిస్తుంది

రెండు మంచి ఎంపికలు ఉన్నాయి. సాధారణంగా జరిగే ఒక తప్పును కూడా గుర్తుంచుకోవాలి.

  • Named volume: pgdata:/var/lib/postgresql/data. Docker ఈ directoryని /var/lib/docker/volumes/<project>_pgdata/_data వద్ద సృష్టిస్తుంది. మొదటి run సమయంలో image entrypoint ownershipను సెట్ చేస్తుంది. సాధారణంగా ఇదే సరైన ఎంపిక.
  • Bind mount: /srv/appname/pg:/var/lib/postgresql/data. Pathను మీరు ఎంచుకుంటారు. కాబట్టి permissions సమస్యను కూడా మీరే పరిష్కరించాలి.
  • ఎలాంటి mount లేకపోవడం. పైన చూడండి. డేటా containerలోనే ఉంటుంది.

పూర్తి trade-off ప్రత్యేక అంశం. bind mounts మరియు named volumes మధ్య తేడాలులో దీనిని వివరించారు. Database కోసం సంక్షిప్తంగా చెప్పాలంటే: host path తెలుసుకోవడానికి ప్రత్యేక కారణం లేకపోతే named volumeను ఉపయోగించండి. Bind mountను ఉపయోగిస్తే, git clean చేరుకోగల project directoryలో కాకుండా /srv/appname/pg వంటి స్థిరమైన ప్రదేశంలో ఉంచండి.

Network storage విషయంలో జాగ్రత్తగా ఉండండి. NFS (network file system) లేదా locking మరియు fsync ప్రవర్తనను మీరు పరీక్షించని మరే network mountలోనైనా database data directoryని ఉంచవద్దు. NFS కోసం PostgreSQL ఒక స్పష్టమైన అవసరాన్ని నమోదు చేస్తుంది: hard optionను ఉపయోగించే mount ఉండాలి. NFS serverలో sync export optionను ఉపయోగించాలని కూడా గట్టిగా సిఫారసు చేస్తుంది. ఇది లేకపోతే clientలోని fsync server diskకు చేరుతుందని హామీ ఉండదు. Databaseలు విజయవంతమైన fsync అంటే bytes స్థిరమైన storageలో రాశారని భావిస్తాయి. ఆ భావన తప్పైతే, వారాల తరువాత బయటపడే data corruption సంభవిస్తుంది.

వాల్యూమ్ కనిపించకుండా పోకముందే దాని పేరును స్థిరపరచండి (Pin)

Compose ఒక వాల్యూమ్‌కు <project>_<volume> అని పేరు పెడుతుంది, మరియు ప్రాజెక్ట్ పేరు డిఫాల్ట్‌గా డైరెక్టరీ పేరును తీసుకుంటుంది. కాబట్టి వాల్యూమ్ గుర్తింపు అనేది డైరెక్టరీ పేరుపై ఆధారపడి ఉంటుంది, దీనిని ఎవరైనా ఆలోచించకుండా మార్చే అవకాశం ఉంది.

మీరు /srv/app ను /srv/app-old కి తరలించినా, లేదా compose ఫైల్‌లోని pgdata కీని పేరు మార్చినా, తదుపరి docker compose up -d కమాండ్ సరికొత్త ఖాళీ వాల్యూమ్‌ను సృష్టిస్తుంది. Postgres అందులో కొత్త క్లస్టర్‌ను ప్రారంభిస్తుంది. కంటైనర్ హెల్తీగా ఉంటుంది, అప్లికేషన్ ప్రారంభమవుతుంది, కానీ పాత టేబుల్స్ అన్నీ పోతాయి. పాత వాల్యూమ్ పాత పేరుతో డిస్క్‌లోనే ఉండటం ఒక మంచి విషయం.

docker volume ls
docker volume inspect app_pgdata

ఇలా జరగకుండా ఉండటానికి పేర్లను స్థిరపరచండి. ప్రాజెక్ట్ పేరును మరియు వాల్యూమ్ పేరును స్పష్టంగా సెట్ చేయండి:

name: myapp

services:
  db:
    image: postgres:17
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata:
    name: myapp_pgdata

ఒకవేళ మీ డేటా ఇప్పటికే వేరే వాల్యూమ్‌లో ఉంటే, డేటాబేస్‌ను ఆపివేసి దానిని కాపీ చేయండి:

docker compose stop db
docker run --rm -v app_pgdata:/from -v myapp_pgdata:/to alpine sh -c 'cp -a /from/. /to/'
docker compose start db

డేటాబేస్ రన్ అవుతున్నప్పుడు కాపీ చేస్తే, అప్పటికే రాయబడుతున్న ఫైల్స్ పాడైపోయే (torn copy) అవకాశం ఉంది. కాబట్టి ముందుగా దానిని ఆపివేయండి.

డేటా డైరెక్టరీని ఎవరు కలిగి ఉంటారు

అధికారిక Postgres, MySQL మరియు MongoDB images తమ server ను ప్రత్యేక హక్కులు లేని numeric user id తో నడుపుతాయి: default tags లో 999, Postgres -alpine tags లో 70. Container root గా ప్రారంభమైనప్పుడు, entrypoint డేటా డైరెక్టరీ ownership ను ఆ user కు మార్చి, తరువాత privileges తగ్గిస్తుంది. అందుకే ఖాళీ bind mount సాధారణంగా మొదటి ప్రయత్నంలోనే పనిచేస్తుంది.

Compose file లో user: సెట్ చేసిన వెంటనే ఇది విఫలమవుతుంది, ఎందుకంటే entrypoint వద్ద ఏదైనా సరిచేయడానికి అవసరమైన privilege మిగలదు. Postgres దీన్ని నేరుగా ఇలా చెబుతుంది:

initdb: error: could not change permissions of directory "/var/lib/postgresql/data": Operation not permitted

తప్పు mode తో ఉన్న data directory వేరే message ఇస్తుంది. దీన్ని గుర్తించడం ముఖ్యం, ఎందుకంటే దీనికి పరిష్కారం chmod, chown కాదు:

FATAL:  data directory "/var/lib/postgresql/data" has invalid permissions
DETAIL:  Permissions should be u=rwx (0700) or u=rwx,g=rx (0750).

MongoDB entrypoint కూడా ownership ను ఇదే విధంగా సరిచేస్తుంది. అందువల్ల ఈ lock file error అంటే అది ownership మార్చలేకపోయిందని అర్థం. సాధారణంగా user: సెట్ అయి ఉంటుంది లేదా mount root నుంచి chown ను నిరాకరిస్తుంది:

Unable to create/open the lock file: /data/db/mongod.lock (Permission denied). Ensure the user executing mongod is the owner of the lock file and has the appropriate permissions.

Host directory ownership ను పేరు ఆధారంగా కాకుండా numeric id కు మార్చాలి:

sudo chown -R 999:999 /srv/appname/pg
sudo chmod 700 /srv/appname/pg
ls -ldn /srv/appname/pg

ls -ldn పేర్లకు బదులుగా numbers ను చూపిస్తుంది. అది 999 999 ను చూపాలి. Postgres -alpine image కోసం 70:70 ఉపయోగించాలి. అప్పుడు 70 70 కనిపించాలి. మీ host లో postgres అనే account, image లో postgres అనే account ఒకదానితో ఒకటి సంబంధం లేనివి. Kernel numbers ను పోల్చుతుంది. పేర్లు ప్రతి వైపు విడిగా lookup చేయబడతాయి. PUID మరియు PGID host users ను container లోకి ఎలా map చేస్తాయో ఆ mapping ను సరిగ్గా వివరిస్తుంది. Rootless Docker లేదా user namespace remapping ఉపయోగించినప్పుడు ఈ numbers మళ్లీ మారవచ్చు. అందువల్ల 999 అని ఊహించకుండా, నడుస్తున్న container నుంచి ids చదవాలి.

Named volumes ఉపయోగిస్తే మొదటి run లోనే ఈ మొత్తం సమస్య తొలగిపోతుంది. Docker ఖాళీ directory ను సృష్టించి, entrypoint దాని ownership ను నిర్వహిస్తుంది.

అప్‌గ్రేడ్‌లు: package upgrade మరియు image tag మార్పు

Hostపై, apt upgrade ద్వారా minor versionలో ముందుకు వెళ్తారు. మీ distribution మీ అనుమతి లేకుండా database major versionను మార్చదు. మీరు major versionకు మారాలని ఎంచుకున్నప్పుడు, రెండు binary సమూహాలను ఒకేసారి install చేయవచ్చు. pg_upgrade కు అవసరమైనది ఇదే.

Containerలో tagనే versionగా ఉపయోగిస్తారు. కాబట్టి upgrade అంటే ఒక lineను మార్చడం. అందువల్ల minor upgrades సులభం. Major upgradesకు మాత్రం విధానం అవసరం.

postgres:16 ను postgres:17 కు మార్చి, docker compose up -d నడిపితే container వెంటనే exit అవుతుంది:

PostgreSQL Database directory appears to contain a database; Skipping initialization
FATAL:  database files are incompatible with server
DETAIL:  The data directory was initialized by PostgreSQL version 16, which is not compatible with this version 17.

ఏదీ పాడవదు. కొత్త binaries పాత on-disk catalog layoutను చదవడానికి నిరాకరిస్తాయి. ఈ layout major versions మధ్య మారుతుంది. Tagను తిరిగి postgres:16 కు మార్చితే అది మళ్లీ start అవుతుంది. Containers అందించే నిజమైన upgrade ప్రయోజనం ఇదే: rollback సులభంగా చేయగలగడం.

మద్దతు ఉన్న విధానం dump మరియు restore. PostgreSQL dumpను కొత్త clientతో తీసుకోవడాన్ని ఇష్టపడుతుంది. అందువల్ల compose networkలో ఇంకా నడుస్తున్న పాత serverపై కొత్త image నుంచి దీన్ని నడపండి:

docker run --rm --network myapp_default -e PGPASSWORD="$POSTGRES_PASSWORD" \
  postgres:17 pg_dumpall -h db -U postgres > /srv/backups/all.sql
ls -lh /srv/backups/all.sql
tail -n 2 /srv/backups/all.sql

ఆ file కనీసం tens of kilobytes పరిమాణంలో ఉండాలి. చివర్లో PostgreSQL database cluster dump complete ఉన్న line ఉండాలి. కొన్ని hundred bytes మాత్రమే ఉన్న file అంటే dump విఫలమైంది. అలాంటి సమయంలో మీరు కారణం లేకుండా volumeను delete చేయబోతున్నారు. ఈ తనిఖీ పూర్తయిన తర్వాత మాత్రమే:

docker compose down
docker volume rm myapp_pgdata
# edit the compose file: image: postgres:17
docker compose up -d db
docker compose exec -T db psql -U postgres -f /dev/stdin < /srv/backups/all.sql

postgres:18 వద్ద మరో మార్పు చేయడానికి సిద్ధంగా ఉండండి. 18 నుంచి official image తన dataను /var/lib/postgresql కింద versioned directoryలో ఉంచుతుంది. 18 కోసం directory /var/lib/postgresql/18/docker. ఇది తన volumeను /var/lib/postgresql వద్ద declare చేస్తుంది. ఇంకా /var/lib/postgresql/data వద్ద mount చేసిన volume ఉంటే, Error: in 18+, these Docker images are configured to store database data తో ప్రారంభమయ్యే errorతో container exit అవుతుంది. 18 లేదా తదుపరి versionకు మారినప్పుడు mountను pgdata:/var/lib/postgresql కు మార్చండి. ఈ postలోని /var/lib/postgresql/data paths 17 మరియు అంతకుముందు versionsకు సంబంధించినవి.

ఇతర enginesలో విధానం వేరుగా ఉంటుంది:

  • MySQL 8 startup సమయంలో తన data dictionaryను upgrade చేస్తుంది. అందువల్ల minor tag bump సాధారణంగా restart మాత్రమే. Release seriesల మధ్య major jump చేయడానికి ముందు release notes చదవండి. ఏ సందర్భంలోనైనా ముందుగా dump తీసుకోండి.
  • MariaDBలో కొత్త versionతో server ప్రారంభమైన తర్వాత mariadb-upgrade ను నడపాలి.
  • MongoDBలో ఒకేసారి ఒక major version మాత్రమే upgrade చేయాలి. ప్రతి దశ తర్వాత ముందుకు వెళ్లే ముందు feature compatibility versionను set చేయాలి. ఒక versionను దాటేస్తే mongod start అవదు. Logsలో featureCompatibilityVersion పేరును పేర్కొనే UPGRADE PROBLEM line కనిపిస్తుంది. MongoDB 7.0 నుంచి commandకు explicit confirmation flag అవసరం: db.adminCommand({ setFeatureCompatibilityVersion: "8.0", confirm: true }).
  • Redis పాత snapshot filesను సులభంగా load చేస్తుంది. కొత్త snapshot filesను మాత్రం load చేయదు. అందువల్ల upgrade అంటే restart. Downgrade సమయంలో data load కాకపోవచ్చు.

సాధారణ నియమం: container downgradeను సులభం చేస్తుంది, కానీ upgradeను మరింత సులభం చేయదు.

నా database container code 137తో ఎందుకు exit అవుతుంది?

Kernel యొక్క out of memory (OOM) killer దాన్ని terminate చేసినందువల్ల. 137 అంటే 128కి signal 9ను కలిపిన విలువ.

docker compose ps --all
docker inspect myapp-db-1 | grep -i oomkilled
journalctl -k | tail -n 20

docker compose ps --all, Exited (137) ను చూపిస్తుంది. --all లేకపోతే, Compose ప్రస్తుతం running లో ఉన్న containers ను మాత్రమే జాబితా చేస్తుంది. అందువల్ల ఆగిపోయిన database outputలో కనిపించదు. Inspect outputలోని line "OOMKilled": true అని చూపిస్తుంది. Kernel logలో దీనికి సరిపోయే entry ఉంటుంది:

Memory cgroup out of memory: Killed process 4711 (postgres) total-vm:2170416kB

OOMKilled containerలోని ఒక processను OOM killer terminate చేసిందని మాత్రమే చెబుతుంది. ఇది container స్వంత limit అని తెలిపేది Memory cgroup out of memory prefix. Host మొత్తానికి memory కొరత ఉంటే Out of memory: Killed process log అవుతుంది. అప్పుడు పరిష్కారం containerలో కాదు, hostలో చేయాలి.

ఇది ఎలా జరుగుతుందో చూద్దాం. Containerలో free మరియు /proc/meminfo ఇప్పటికీ host యొక్క మొత్తం memoryని report చేస్తాయి. Cgroup limit ఆ సంఖ్యను మార్చదు. PostgreSQL ఆ సంఖ్య ఆధారంగా దేనినీ size చేయదు. shared_buffers defaultగా 128MB ఉంటుంది. దానికంటే పెద్ద విలువను మీరు లేదా tuning guide ఎంచుకుని ఉంటారు. MySQLలోని innodb_buffer_pool_size కూడా defaultగా 128M ఉంటుంది. Machine report చేసే memory ఆధారంగా settingsను size చేసినప్పుడు సమస్య మొదలవుతుంది. PostgreSQL guidance ప్రకారం, system memoryలో 25%ను ప్రారంభ shared_buffersగా ఉపయోగించవచ్చు. కాబట్టి 2 GB limit ఉన్న 16 GB hostలో ఆ నియమం 4 GB ఇస్తుంది. ఫలితంగా hostపై ఒత్తిడి ఏర్పడకముందే cgroup databaseను terminate చేస్తుంది. కొన్ని engines ఇప్పుడు కొన్ని defaults కోసం limitను చదువుతున్నాయి. MySQL 9.3 మరియు తరువాతి versions అలా చేస్తాయి. MongoDB కూడా limitను గుర్తించగలిగితే WiredTiger cache కోసం ఉపయోగిస్తుంది. అయితే ఇవి అన్నింటినీ దాని ఆధారంగా size చేయవు. MongoDB documentation ప్రకారం detection విఫలమయ్యే అవకాశం కూడా ఉంది. అందువల్ల memory limit మాత్రమే సరిపోదు. Databaseకు అందుబాటులో ఉన్న memoryని మీరు స్పష్టంగా తెలియజేయాలి:

  • PostgreSQL: shared_buffersను set చేయండి. అలాగే work_memపై శ్రద్ధ పెట్టండి. work_mem ప్రతి sort లేదా hash operationకు వర్తిస్తుంది. ప్రతి connection ఒకేసారి అనేక operationsను నడపగలదు. అందువల్ల generous valueను 50 connectionsతో గుణించడం, startup సమయంలో కాకుండా loadలో container ఆగిపోవడానికి సాధారణ కారణం.
  • MySQL మరియు MariaDB: defaultగా 128M ఉండే innodb_buffer_pool_sizeను set చేయండి. 9.3 కంటే ముందు ఉన్న MySQLలో containerలో innodb_dedicated_serverను offగా ఉంచండి. ఇది buffer poolను machine memory ఆధారంగా size చేస్తుంది. Containerలో machine memory అంటే host memory. 9.3 నుండి MySQL container limitsను చదువుతుంది. innodb_dedicated_server వాటి ఆధారంగా size అవుతుంది. అయినప్పటికీ explicit buffer pool size ఉపయోగించడం మరింత అంచనా వేయగల ఎంపిక.
  • MongoDB: WiredTiger cache sizeను explicitగా set చేయండి. MongoDB limitను గుర్తించగలిగితే container limitను ఉపయోగిస్తుంది. (hostInfo దాన్ని memLimitMBగా report చేస్తుంది.) అయితే కొన్ని సందర్భాల్లో detection జరగకపోవచ్చని MongoDB documentation హెచ్చరిస్తుంది. అలాగే --wiredTigerCacheSizeGB లేదా --wiredTigerCacheSizePctను container memory కంటే తక్కువగా set చేయాలని సూచిస్తుంది.
  • Redis: maxmemory defaultగా unlimitedగా ఉంటుంది. అందువల్ల cgroup దాన్ని ఆపే వరకు Redis పెరుగుతూనే ఉంటుంది. maxmemoryను container limit కంటే గణనీయంగా తక్కువగా set చేయండి. అలాగే maxmemory-policyను ఎంచుకోండి.

Postgres తన వైపు నుంచి కూడా ఈ eventను report చేస్తుంది. Logలో ఈ రెండు lines కనిపిస్తాయి:

LOG:  server process (PID 123) was terminated by signal 9: Killed
LOG:  terminating any other active sessions due to crash of another server process

ఒక backend terminate అయితే మిగిలిన ప్రతి backendను restart చేయాల్సి వస్తుంది. ఎందుకంటే shared memory ఇప్పుడు inconsistentగా ఉండవచ్చు. ఇది మీ applicationకు connection storm. ఇది నిశ్శబ్దంగా జరిగే event కాదు. Docker Composeలో memory limits set చేయడంలో syntaxతో పాటు mem_limit మరియు deploy.resources form మధ్య తేడా వివరించబడింది.

ఇవేవీ hostలో అదృశ్యం కావు. సమస్య కేవలం host స్థాయికి మారుతుంది. Cgroup లేకపోతే database hostలోని మిగతా అన్నింటితో memory కోసం పోటీ పడుతుంది. అప్పుడు host OOM killer score ఆధారంగా ఒక victimను ఎంచుకుంటుంది. ఆ victim sshd కూడా కావచ్చు. Databaseను అంచనా వేయగలిగే విధంగా terminate చేసే limit, మిమ్మల్ని host నుంచి lock out చేసే host OOM కంటే నిర్వహించడం సులభం.

బ్యాకప్‌లు: లోపల డంప్ చేయండి, బయట బ్యాకప్ చేయండి

నడుస్తున్న డేటాబేస్‌ను దాని డేటా డైరెక్టరీని కాపీ చేయడం ద్వారా బ్యాకప్ చేయవద్దు. సర్వర్ డేటాను రాస్తున్నప్పుడు ఫైల్-స్థాయి కాపీని తీసుకుంటే అది అసంపూర్ణంగా (torn copy) ఉంటుంది, ఇది మీరు డేటాను పునరుద్ధరించేటప్పుడు (restore) తెలుస్తుంది.

రెండు సరైన పద్ధతులు ఉన్నాయి: డేటాబేస్ నడుస్తున్నప్పుడు దాని స్వంత టూల్‌తో డంప్ తీసి ఆ డంప్‌ను బ్యాకప్ చేయడం, లేదా కంటైనర్‌ను ఆపివేసి వాల్యూమ్‌ను కోల్డ్ కాపీ (cold copy) చేయడం.

docker compose exec -T db pg_dump -U postgres -Fc appdb > /srv/backups/appdb.dump
docker compose exec -T db mysqldump -u root -p"$MYSQL_ROOT_PASSWORD" --single-transaction --all-databases > /srv/backups/mysql.sql
docker compose exec -T db mongodump --archive --gzip --db appdb > /srv/backups/appdb.archive.gz
docker compose exec -T redis redis-cli BGSAVE

-T చాలా ముఖ్యం. ఇది లేకపోతే, docker compose exec కమాండ్‌కు టెర్మినల్‌ను అటాచ్ చేయవచ్చు, దీనివల్ల టెర్మినల్ లేయర్ అవుట్‌పుట్ స్ట్రీమ్‌కు క్యారేజ్ రిటర్న్‌లను జోడిస్తుంది. అప్పుడు టెక్స్ట్ డంప్ వింతైన లోపాలతో పునరుద్ధరించబడుతుంది మరియు బైనరీ డంప్ పూర్తిగా పాడవుతుంది. ఇది బ్యాకప్ సమయంలో నిశ్శబ్దంగా విఫలమవుతుంది, కానీ ఒక నెల తర్వాత పునరుద్ధరించేటప్పుడు పెద్ద సమస్యగా మారుతుంది.

--single-transaction అనేది మొత్తం సర్వర్‌ను లాక్ చేయకుండానే InnoDB టేబుల్స్ యొక్క స్థిరమైన స్నాప్‌షాట్‌ను mysqldump కి అందిస్తుంది.

ఈ కమాండ్‌లు ఒక్కో ఫైల్‌ను మాత్రమే రాస్తాయి. ఇవి బ్యాకప్ సిస్టమ్ కాదు: ఇందులో రిటెన్షన్ (retention), బాహ్య కాపీ (off-box copy), మరియు వెరిఫికేషన్ ఉండవు. ఈ డంప్ డైరెక్టరీని ఈ మూడు పనులను చేసే ఒక టూల్‌కు అప్పగించండి, దీని కోసమే restic backups from a VPS ఉపయోగపడుతుంది. /var/lib/docker/volumes ని కాదు, /srv/backups ని బ్యాకప్ చేయండి.

తర్వాత పునరుద్ధరణను (restore) పరీక్షించండి, ఎందుకంటే మీరు ఎప్పుడూ పునరుద్ధరించని బ్యాకప్ అసలు బ్యాకపే కాదు:

docker compose exec -T db createdb -U postgres restore_test
docker compose exec -T db pg_restore -U postgres -d restore_test < /srv/backups/appdb.dump
docker compose exec -T db psql -U postgres -d restore_test -c '\dt'

\dt మీ అప్లికేషన్ యొక్క టేబుల్స్‌ను చూపించాలి. ఫలితం ఖాళీగా ఉన్నా, లేదా Did not find any relations. అని వచ్చినా, డంప్ మీరు అనుకున్నట్లుగా లేదని అర్థం. పని పూర్తయ్యాక restore_test ని తొలగించండి.

అన్నింటినీ తొలగించే కమాండ్

docker compose down -v.

సాధారణ down కంటైనర్లను మరియు నెట్‌వర్క్‌ను తొలగిస్తుంది. -v ఆ compose ఫైల్‌లో పేర్కొన్న ప్రతి named volume ను, మరియు ఆ కంటైనర్లకు అనుసంధానించబడిన ప్రతి anonymous volume ను కూడా తొలగిస్తుంది. దీనికి ఎటువంటి నిర్ధారణ (prompt) అడగదు మరియు దీనిని వెనక్కి తీసుకోవడం (undo) సాధ్యం కాదు. self-hosted డేటాబేస్ తొలగిపోవడానికి ఇది అత్యంత సాధారణ కారణం. సంబంధం లేని ఏదైనా సమస్యను పరిష్కరించేటప్పుడు, ఫోరమ్‌లో ఎవరైనా దీనిని రన్ చేయమని చెప్పడం వల్ల ఇది తరచుగా జరుగుతుంది.

ప్రమాద తీవ్రతను తగ్గించడానికి నాలుగు మార్గాలు ఉన్నాయి:

  • డేటాబేస్ వాల్యూమ్‌ను external: true గా ప్రకటించండి. Compose తన ఆధీనంలో లేని వాల్యూమ్‌ను తొలగించదు, కాబట్టి -v దానిని ఏమీ చేయలేదు. మీరు దీనిని docker volume create myapp_pgdata తో ఒకసారి సృష్టించుకోవాలి.
  • సాధారణ రీస్టార్ట్‌ల కోసం docker compose stop మరియు docker compose start ఉపయోగించండి. Compose లో down మరియు stop మధ్య తేడా ప్రతి ఒక్కటి దేనిని తొలగిస్తుందో వివరిస్తుంది.
  • Compose నిర్వహించే ప్రతి వాల్యూమ్ వెలుపల, హోస్ట్ పాత్‌లో డేటాబేస్ డంప్‌లను ఉంచండి.
  • మీకు ముఖ్యమైన డేటా ఉన్న స్టాక్‌లో, ట్రబుల్‌షూటింగ్ సమాధానాల నుంచి వచ్చే -v కమాండ్‌ను ఎప్పుడూ కాపీ-పేస్ట్ చేయవద్దు.

డేటాబేస్ పోర్ట్‌ను పబ్లిక్ చేయవద్దు

ఈ లైన్ మీ డేటాబేస్‌ను పబ్లిక్ ఇంటర్నెట్‌కు బహిర్గతం చేస్తుంది:

    ports:
      - "5432:5432"

ఇది ప్రతి నెట్‌వర్క్ ఇంటర్‌ఫేస్‌కు బైండ్ అవుతుంది. Docker ఒక పోర్ట్‌ను పబ్లిక్ చేసినప్పుడు, మీ ఫైర్‌వాల్ ఇన్‌పుట్ రూల్స్ చూడకముందే అది ప్యాకెట్ యొక్క డెస్టినేషన్‌ను మారుస్తుంది. ufw రూల్స్ ఇన్‌పుట్ చైన్‌లో ఉంటాయి కాబట్టి, ufw deny 5432 ఏమాత్రం పనిచేయదు. Docker పబ్లిష్ చేసిన పోర్ట్‌లు ufw ను ఎందుకు దాటవేస్తాయి అనే అంశం చైన్ ట్రావర్సల్‌ను వివరిస్తుంది.

ఒకే compose ప్రాజెక్ట్‌లోని అప్లికేషన్, compose నెట్‌వర్క్ ద్వారా సర్వీస్ పేరుతోనే డేటాబేస్‌ను చేరుకోగలదు, కాబట్టి దానికి పబ్లిష్ చేసిన పోర్ట్ అవసరం లేదు. ఆ బ్లాక్‌ను తొలగించండి. ఒకవేళ మీకు హోస్ట్ మెషీన్ నుండి క్లయింట్ యాక్సెస్ కావాలంటే, loopback కు మాత్రమే బైండ్ చేయండి:

    ports:
      - "127.0.0.1:5432:5432"

ప్రస్తుతం ఏది వింటోందో (listening) తనిఖీ చేయండి:

sudo ss -ltnp | grep 5432

127.0.0.1:5432 అనేది మీరు ఆశించే ఫలితం. 0.0.0.0:5432 అంటే ఎవరైనా మీ పాస్‌వర్డ్‌ను ప్రయత్నించే అవకాశం ఉందని అర్థం.

ఎక్కడ ఏమి రన్ చేయాలి

ఒక VPSలో ఒక అప్లికేషన్. కంటైనర్ వాడండి. పేరు నిర్ణయించిన (pinned name) వాల్యూమ్‌ను ఉపయోగించండి, పోర్ట్‌ను పబ్లిష్ చేయకండి, డేటాబేస్ సెట్టింగ్‌లకు అనుగుణంగా మెమరీ పరిమితిని విధించండి, మరియు ప్రతిరోజూ రాత్రి ఒక dump ఫైల్‌ను హోస్ట్ పాత్‌లోకి తీసుకోండి, దానిని restic సేకరిస్తుంది. VPSలో క్లీన్ Docker ఇన్‌స్టాలేషన్ తో ప్రారంభించి, మొత్తం stackను ఒకే compose ఫైల్‌లో ఉంచి gitలో commit చేయండి. దీనివల్ల డేటాబేస్ వెర్షన్ gitలో రివ్యూ చేయదగిన లైన్‌గా మారుతుంది, ఇది చాలా ఉపయోగకరం.

అనేక సేవలు నడిచే హోస్ట్. కంటైనర్లను వాడండి, ప్రతి అప్లికేషన్‌కు ఒక ప్రత్యేక డేటాబేస్ ఉండాలి, అన్నింటికీ కలిపి ఒకే షేర్డ్ సర్వర్ ఉండకూడదు. షేర్డ్ సర్వర్ వల్ల అన్ని అప్లికేషన్లు ఒకే అప్‌గ్రేడ్ షెడ్యూల్‌కు కట్టుబడి ఉండాల్సి వస్తుంది, ఒకే ఒక తప్పు క్వెరీ వల్ల అన్ని సేవలు ఆగిపోయే ప్రమాదం ఉంది. ప్రతి కంటైనర్‌కు మెమరీ పరిమితిని సెట్ చేయండి, తద్వారా ఒక చెడు క్వెరీ ఆ అప్లికేషన్‌కే పరిమితం అవుతుంది. చిన్న చిన్న Postgres ఇన్‌స్టాన్సులను వాడటం వల్ల డిస్క్ స్పేస్ కొంచెం ఎక్కువ ఖర్చయినా, నిర్వహణ చాలా సులభం అవుతుంది.

డేటాబేసే ప్రధాన ఉత్పత్తి. దీనిని వెండర్ ప్యాకేజీ రిపోజిటరీ నుండి హోస్ట్‌పై రన్ చేయండి లేదా మేనేజ్డ్ సర్వీస్‌ను ఎంచుకోండి. pg_upgrade కి ఒకే సమయంలో రెండు ప్రధాన వెర్షన్ల బైనరీలు అవసరం కావచ్చు, ఇది ప్యాకేజీల ద్వారా సాధ్యమవుతుంది కానీ సింగిల్-వెర్షన్ ఇమేజ్‌లో సాధ్యం కాదు. డేటాబేస్ నేరుగా మెషీన్ మరియు డిస్క్‌లను నియంత్రిస్తున్నప్పుడు, WAL (write ahead log) ఆర్కైవింగ్‌తో రెప్లికేషన్ మరియు పాయింట్-ఇన్-టైమ్ రికవరీ సులభం అవుతాయి. రాత్రి 03:00 గంటలకు మీకు అలర్ట్ వచ్చే అవకాశం ఉన్న సిస్టమ్ కోసం ఎప్పుడూ నమ్మదగిన, సాధారణ పద్ధతినే ఎంచుకోండి.

అప్లికేషన్ చిన్నది. సర్వర్ డేటాబేస్ లేకుండా రన్ చేయడం గురించి ఆలోచించండి. ఒక VPSలో సింగిల్-రైటర్ వెబ్ అప్లికేషన్ కోసం VPSలో SQLite వాడటం తరచుగా మంచిది. ఇందులో బ్యాకప్ అంటే ఒకే ఒక ఫైల్, మరియు అప్‌గ్రేడ్ అంటే కేవలం లైబ్రరీ వెర్షన్‌ను మార్చడమే.

FAQ

ఉత్పత్తి డేటాబేస్‌ను Dockerలో నడపడం సురక్షితమేనా?

అవును, ఒకే సర్వర్ అప్లికేషన్ stack కోసం ఇది సురక్షితం. Container అనేది దాని చుట్టూ namespaces మరియు cgroups ఉన్న Linux process. కాబట్టి volume mount చేసినప్పుడు, package నుంచి install చేసినా database ఉపయోగించే అదే host filesystemలోకి ఇది రాస్తుంది. ప్రమాదాలు వేగానికి సంబంధించినవి కావు; అవి నిర్వహణకు సంబంధించినవి: పేరు pin చేయని volume, తప్పు user idకి చెందిన bind mount, ఎప్పుడూ పరీక్షించని restore, మరియు docker compose down -v. ఈ నాలుగు సమస్యలను నివారిస్తే container సరిగానే పనిచేస్తుంది. Database ప్రధాన workload అయి, pg_upgrade, replication లేదా point in time recovery అవసరమైతే host installకు మారండి.

డేటాబేస్ data కోసం bind mount ఉపయోగించాలా లేదా named volume ఉపయోగించాలా?

Host path తెలుసుకోవడానికి ప్రత్యేక కారణం లేకపోతే named volume ఉపయోగించండి. Docker directoryని సృష్టిస్తుంది. మొదటి start సమయంలో image entrypoint ownershipను సెట్ చేస్తుంది. అందువల్ల permission సమస్య కనిపించదు. Explicit name:తో volumeను pin చేయండి లేదా దాన్ని external: trueగా mark చేయండి. లేకపోతే project directoryని rename చేసినప్పుడు కొత్త ఖాళీ volume మరియు ఖాళీ database నిశ్శబ్దంగా ఏర్పడతాయి. Host directoryని image నడిచే numeric user idకి chown చేస్తే bind mount కూడా సరిపోతుంది. Official Postgres, MySQL మరియు MongoDB imagesలోని default tagsకు ఈ id 999. Postgres -alpine tagsకు ఇది 70. ls -ldnతో దీన్ని verify చేయండి. ఎందుకంటే ls -l మీ hostలో ఆ సంఖ్యకు ఉన్న పేరును చూపిస్తుంది. ఆ పేరు containerలో అర్థరహితం.

docker compose down -v ఏమి delete చేస్తుంది?

సాధారణ downలాగే ఇది containers మరియు networkను తొలగిస్తుంది. అదనంగా -v ఆ compose fileలో declare చేసిన ప్రతి named volumeను, అలాగే ఆ containersకు attached అయిన ప్రతి anonymous volumeను తొలగిస్తుంది. ఇందులో database కూడా ఉంటుంది. Confirmation prompt ఉండదు. Recovery కూడా ఉండదు. external: trueగా mark చేసిన volumes తొలగించబడవు. Database volumeను externalగా mark చేయడానికి ఇదే ప్రధాన కారణం. సాధారణ restart కోసం docker compose stop మరియు docker compose start ఉపయోగించండి.

Dockerలో PostgreSQLను కొత్త major versionకు ఎలా upgrade చేయాలి?

Dump చేసి restore చేయండి. postgres:16ను postgres:17గా మార్చి restart చేస్తే FATAL: database files are incompatible with server వస్తుంది. రెండు versions పేర్లను చూపించే DETAIL line కూడా కనిపిస్తుంది. ఎందుకంటే కొత్త binaries పాత catalog layoutను చదవలేవు. ఏదీ దెబ్బతినదు. పాత tagను తిరిగి ఉంచితే అది start అవుతుంది. నడుస్తున్న పాత containerకు కొత్త version clientను ఉపయోగించి pg_dumpall తీసుకోండి. File చివర PostgreSQL database cluster dump completeతో ముగుస్తుందని నిర్ధారించండి. తరువాత ఖాళీ volumeపై కొత్త tagను ప్రారంభించి dumpను load చేయండి. postgres:18 నుంచి ఆ volumeను /var/lib/postgresql వద్ద mount చేయండి; /var/lib/postgresql/data వద్ద కాదు. ఒకే major versionలోని minor upgradesకు pull మరియు restart మాత్రమే అవసరం.

నా database container code 137తో ఎందుకు exit అవుతోంది?

137 అంటే 128కి signal 9 కలిసిన విలువ. కాబట్టి ఏదో processను పూర్తిగా terminate చేసింది. docker inspect <container> | grep -i oomkilled నడపండి. true విలువ అంటే containerలోని ఒక processను OOM killer terminate చేసిందని అర్థం. సాధారణంగా container తన cgroup memory limitను తాకినప్పుడు ఇది జరుగుతుంది. సాధారణ కారణం host కోసం నిర్ణయించిన memory settingsను containerకు కూడా ఉపయోగించడం. Containerలోని tools ఇప్పటికీ host మొత్తం memoryని చూపిస్తాయి. అందువల్ల 16 GB కోసం నిర్ణయించిన buffer, 2 GBలో నడుస్తున్న containerలోనే ఉండిపోతుంది. Containerకు ఇచ్చిన limitకు సరిపడేలా shared_buffers మరియు work_mem సెట్ చేయండి, లేదా innodb_buffer_pool_size సెట్ చేయండి. ఏ processను kernel ఎంచుకుందో, అది host-wide Out of memory kill కాకుండా container limit వల్లే జరిగిందో నిర్ధారించడానికి journalctl -kలో సరిపోలే Memory cgroup out of memory lineను పరిశీలించండి.

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