SSD Nodes Learn Hosting plans →
मार्गदर्शक Matt Connorद्वारे Matt Connor · अपडेटेड 2026-10-24

डेटाबेस Docker मध्ये चालवावा की होस्टवर?

PostgreSQL, MySQL, MongoDB किंवा Redis कंटेनरमध्ये चालवणे सुरक्षित आहे का? डेटाबेस व्हॉल्यूम्स, बॅकअप, मेमरी लिमिट्स आणि अपग्रेडच्या आव्हानांची सविस्तर माहिती या लेखात दिली आहे.

डेटाबेस Docker मध्ये चालवावा की होस्टवर?

डेटाबेस Docker मध्ये चालवा. एका VPS वर एका ॲप्लिकेशन स्टॅकसाठी, कंटेनराइज्ड PostgreSQL, MySQL, MongoDB किंवा Redis हा एक सामान्य प्रॉडक्शन पर्याय आहे आणि त्याबद्दल होणारी चर्चा सहसा चुकीच्या मुद्द्यांवर आधारित असते. कंटेनर म्हणजे Linux प्रोसेस असते, ज्याच्या भोवती namespaces आणि cgroups असतात; ती व्हर्च्युअल मशीन नसते, त्यामुळे डेटाबेस आणि डिस्कच्या मध्ये कोणताही हायपरवाइजर नसतो. bind mount किंवा लोकल named volume वापरल्यास, वाचन आणि लेखनाच्या क्रिया थेट होस्ट फाइलसिस्टमवर होतात, जी पॅकेज इन्स्टॉल करताना वापरली जाणारी फाइलसिस्टमच असते.

याचा खरा खर्च ऑपरेशनल असतो. ही रचना योग्य ठरेल की एक संथ आपत्ती, हे चार गोष्टी ठरवतात: डेटा कुठे साठवला जातो, त्या डिरेक्टरीचा मालक कोण आहे, मेजर व्हर्जन अपग्रेडची प्रक्रिया कशी आहे आणि तुम्ही कधी बॅकअप रिस्टोअर केला आहे का. या गोष्टी नीट हाताळल्यास कंटेनर हा केवळ एक तांत्रिक तपशील उरतो. जर या गोष्टी चुकल्या, तर तुम्ही कंटेनरलाच दोष द्याल.

प्रत्येक सर्व्हर डेटाबेससाठी हा निर्णय सारखाच असतो. खालील उदाहरणांमध्ये PostgreSQL, MySQL, MongoDB आणि Redis चा वापर केला आहे आणि जिथे आवश्यक आहे तिथे उत्पादन-विशिष्ट फरक स्पष्ट केले आहेत.

कंटेनर प्रत्यक्षात काय बदलतो

जोपर्यंत तुम्ही स्टोरेज पाथ माउंट करता, तोपर्यंत तो बदलत नाही. कर्नल, पेज कॅशे आणि फाईलसिस्टम तीच राहते.

एक खरा परफॉर्मन्सचा धोका आहे, तो म्हणजे जेव्हा तुम्ही काहीही माउंट करत नाही. व्हॉल्यूमशिवाय, डेटा डिरेक्टरी कंटेनरच्या रायटेबल लेयरमध्ये जाते, जी इमेजवर आधारित ओव्हरले फाईलसिस्टम असते. तिथे लिहिण्याची प्रक्रिया संथ असते आणि कंटेनर काढून टाकल्यावर संपूर्ण लेयर नष्ट होते. "आज सकाळी माझा डेटाबेस रिकामा होता" ही समस्या याच कारणामुळे उद्भवते.

जे खरोखर बदलते:

  • लाईफसायकल. docker compose down कंटेनर नष्ट करते. व्हॉल्यूममध्ये नसलेली कोणतीही गोष्ट त्यासोबत नष्ट होते.
  • व्हर्जन. इमेज टॅग हेच व्हर्जन असते. डेटाबेस कंटेनरच्या आत असे कोणतेही apt upgrade नसते जे पुढच्या docker compose pull नंतर टिकून राहील.
  • मेमरी अकाउंटिंग. cgroup मर्यादा ही कर्नलद्वारे लागू केलेली एक कठोर भिंत आहे आणि बहुतेक डेटाबेसची डीफॉल्ट सेटिंग्ज स्वतःला त्या मर्यादेनुसार जुळवून घेत नाहीत. MySQL 9.3 किंवा त्यानंतरची आवृत्ती काही सेटिंग्जसाठी ही मर्यादा वाचते. MongoDB त्याच्या WiredTiger कॅशेसाठी तसा प्रयत्न करते, परंतु त्यांच्या स्वतःच्या डॉक्युमेंटेशनमध्ये काही प्रकरणांमध्ये ते शोधणे अयशस्वी होऊ शकते असा इशारा दिला आहे. PostgreSQL आणि Redis असे करत नाहीत.
  • युजर. प्रोसेस कंटेनरच्या आत एका अंकीय युजर आयडी (numeric user id) म्हणून चालते, ज्याची तुमच्या होस्टवर कोणतीही मालकी नसू शकते.

डेटा कोठे साठवला जातो यावर सर्व काही अवलंबून असते

येथे दोन चांगले पर्याय आहेत आणि एक सामान्य चूक आहे.

  • Named volume: pgdata:/var/lib/postgresql/data. Docker /var/lib/docker/volumes/<project>_pgdata/_data वर डिरेक्टरी तयार करते आणि इमेजचे entrypoint पहिल्या रनवेळी मालकी हक्क (ownership) सेट करते. हे डीफॉल्ट उत्तर आहे.
  • Bind mount: /srv/appname/pg:/var/lib/postgresql/data. तुम्ही पाथ निवडता, त्यामुळे परवानग्यांची जबाबदारी तुमची असते.
  • कोणताही mount न वापरणे. वर नमूद केल्याप्रमाणे, डेटा कंटेनरच्या आतच राहतो.

यातील पूर्ण तडजोड हा एक स्वतंत्र विषय आहे आणि bind mounts against named volumes मध्ये तो कव्हर केला आहे. डेटाबेससाठी थोडक्यात सांगायचे तर: जोपर्यंत तुम्हाला होस्ट पाथ माहित असण्याचे विशिष्ट कारण नसेल, तोपर्यंत named volume वापरा. जर तुम्ही bind mount वापरत असाल, तर ते प्रोजेक्ट डिरेक्टरीच्या आत ठेवण्याऐवजी /srv/appname/pg सारख्या स्थिर ठिकाणी ठेवा, जेणेकरून git clean तिथे पोहोचू शकणार नाही.

नेटवर्क स्टोरेज वापरताना काळजी घ्या. डेटाबेसची डेटा डिरेक्टरी NFS (network file system) किंवा अशा कोणत्याही नेटवर्क माउंटवर ठेवू नका ज्याचे लॉकिंग आणि fsync वर्तन तुम्ही तपासलेले नाही. PostgreSQL ने NFS साठी एक अट स्पष्ट केली आहे: माउंट करताना hard पर्याय वापरावा. तसेच, NFS सर्व्हरवर sync एक्सपोर्ट पर्याय वापरण्याची जोरदार शिफारस केली जाते, कारण त्याशिवाय क्लायंटवरील fsync सर्व्हरच्या डिस्कपर्यंत पोहोचेलच याची खात्री नसते. डेटाबेस असे गृहीत धरतात की यशस्वी fsync चा अर्थ असा आहे की बाइट्स स्थिर स्टोरेजवर (stable storage) पोहोचले आहेत. जेव्हा हे गृहीतक चुकीचे ठरते, तेव्हा डेटा करप्शन होते जे काही आठवड्यांनंतर दिसून येते.

व्हॉल्यूम गहाळ होण्यापूर्वी त्याचे नाव पिन करा

Compose व्हॉल्यूमचे नाव <project>_<volume> असे ठेवते आणि प्रोजेक्टचे नाव डीफॉल्टनुसार डिरेक्टरीच्या नावावरून ठरते. त्यामुळे व्हॉल्यूमची ओळख डिरेक्टरीच्या नावावर अवलंबून असते, जे लोक विचार न करता बदलतात.

जर तुम्ही /srv/app ला /srv/app-old मध्ये हलवले किंवा compose फाईलमधील pgdata की (key) बदलली, तर पुढच्या वेळी 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

डेटाबेस सुरू असताना कॉपी केल्यास फाईल्स अर्धवट कॉपी होऊ शकतात, कारण त्या वेळी त्यामध्ये लिहीले जात असते. त्यामुळे आधी डेटाबेस थांबवा.

डेटा डिरेक्टरीची मालकी कोणाकडे आहे

अधिकृत Postgres, MySQL आणि MongoDB इमेजेस त्यांच्या डीफॉल्ट टॅगवर 999 या अनप्रिव्हिलेज्ड (unprivileged) न्यूमेरिक युजर आयडीवर आणि Postgres च्या -alpine टॅगवर 70 या आयडीवर सर्व्हर चालवतात. जेव्हा कंटेनर root म्हणून सुरू होतो, तेव्हा एंट्रीपॉईंट डेटा डिरेक्टरीची मालकी त्या युजरकडे सोपवतो आणि त्यानंतर प्रिव्हिलेज सोडून देतो. म्हणूनच रिकामे bind mount सहसा पहिल्या प्रयत्नात काम करते.

जेव्हा तुम्ही compose फाईलमध्ये user: सेट करता, तेव्हा ही प्रक्रिया बिघडते, कारण त्यानंतर एंट्रीपॉईंटकडे कोणतीही गोष्ट दुरुस्त करण्यासाठी प्रिव्हिलेज उरत नाही. Postgres हे थेट सांगते:

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

चुकीच्या मोडमध्ये असलेली डेटा डिरेक्टरी वेगळा संदेश देते, आणि हा संदेश ओळखणे महत्त्वाचे आहे कारण याचे निराकरण 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 एंट्रीपॉईंट देखील मालकी हक्क अशाच प्रकारे दुरुस्त करतो, त्यामुळे या लॉक फाईल एररचा अर्थ असा होतो की तो तसे करू शकला नाही: सहसा user: सेट केलेले असते, किंवा mount रूटकडून येणाऱ्या 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.

याचे निराकरण म्हणजे होस्ट डिरेक्टरीची मालकी नावाऐवजी न्यूमेरिक आयडीकडे सोपवणे (chown):

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

ls -ldn नावाऐवजी नंबर दाखवते आणि तिथे 999 999 दिसले पाहिजे. Postgres -alpine इमेजसाठी, त्याऐवजी 70:70 वापरा आणि 70 70 ची अपेक्षा ठेवा. तुमच्या होस्टवरील postgres नावाचे खाते आणि इमेजमधील postgres नावाचे खाते यांचा एकमेकांशी संबंध नसतो: कर्नल फक्त नंबरची तुलना करते आणि नावे दोन्ही बाजूंना स्वतंत्रपणे शोधली जातात. PUID आणि PGID होस्ट युजर्सना कंटेनरमध्ये कसे मॅप करतात हे त्या मॅपिंगची सविस्तर माहिती देते. rootless Docker किंवा युजर नेमस्पेस रिमॅपिंग अंतर्गत हे नंबर पुन्हा बदलतात, त्यामुळे 999 गृहीत धरण्याऐवजी चालू असलेल्या कंटेनरमधून आयडी तपासा.

Named volumes वापरल्यास हा संपूर्ण विभाग पहिल्या रनलाच लागू होत नाही, कारण Docker एक रिकामी डिरेक्टरी तयार करते आणि एंट्रीपॉईंट तिची मालकी घेतो.

अपग्रेड्स: पॅकेज अपग्रेड विरुद्ध इमेज टॅग बदल

होस्टवर, apt upgrade तुम्हाला मायनर व्हर्जनवर पुढे नेते. तुमची डिस्ट्रिब्युशन तुमच्या नकळत डेटाबेसचे मेजर व्हर्जन बदलणार नाही आणि जेव्हा तुम्ही ते बदलण्याचे ठरवता, तेव्हा दोन्ही बायनरीज एकाच वेळी इन्स्टॉल केल्या जाऊ शकतात, जे pg_upgrade साठी आवश्यक असते.

कंटेनरमध्ये टॅग हेच व्हर्जन असते, त्यामुळे अपग्रेड म्हणजे फक्त एक ओळ बदलणे होय. यामुळे मायनर अपग्रेड्स सोपे होतात आणि मेजर अपग्रेड्स एक प्रक्रिया बनतात.

postgres:16 ला postgres:17 मध्ये बदला, docker compose up -d चालवा आणि कंटेनर त्वरित बंद होतो:

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.

काहीही खराब होत नाही. नवीन बायनरीज जुन्या ऑन-डिस्क कॅटलॉग लेआउटला वाचण्यास नकार देतात, जो मेजर व्हर्जन दरम्यान बदलतो. टॅग पुन्हा postgres:16 वर सेट करा आणि तो पुन्हा सुरू होतो. तो रोलबॅक हा कंटेनरचा अपग्रेडमधील एक खरा फायदा आहे.

समर्थित मार्ग म्हणजे डंप आणि रिस्टोअर. PostgreSQL ला डंप नवीन क्लायंटद्वारे घेणे सोयीचे वाटते, म्हणून नवीन इमेजवरून कंपोज नेटवर्कवर अजूनही चालू असलेल्या जुन्या सर्व्हरवर ते चालवा:

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

फाईल किमान काही दहापट किलोबाइट्सची असावी आणि ती PostgreSQL database cluster dump complete ही ओळ वाचून संपली पाहिजे. काही शंभर बाईट्सची फाईल म्हणजे डंप अयशस्वी झाला आहे आणि तुम्ही विनाकारण व्हॉल्यूम डिलीट करण्याच्या तयारीत आहात. ही तपासणी केल्यानंतरच:

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 पासून, अधिकृत इमेज आपला डेटा /var/lib/postgresql (18 साठी, /var/lib/postgresql/18/docker) अंतर्गत व्हर्जन डिरेक्टरीमध्ये ठेवते आणि आपला व्हॉल्यूम /var/lib/postgresql वर घोषित करते. अजूनही /var/lib/postgresql/data वर माउंट केलेला व्हॉल्यूम कंटेनरला Error: in 18+, these Docker images are configured to store database data ने सुरू होणाऱ्या त्रुटीसह बंद करण्यास भाग पाडतो. जेव्हा तुम्ही 18 किंवा त्यानंतरच्या आवृत्तीवर जाता, तेव्हा माउंट pgdata:/var/lib/postgresql वर बदला. या पोस्टमधील /var/lib/postgresql/data पाथ 17 आणि त्यापूर्वीच्या आवृत्तीसाठी आहेत.

इतर इंजिन्स वेगळी आहेत:

  • MySQL 8 स्टार्टअपवर स्वतःचा डेटा डिक्शनरी अपग्रेड करते, त्यामुळे मायनर टॅग बदलणे म्हणजे सहसा फक्त रीस्टार्ट करणे असते. रिलीज सीरिज दरम्यान बदल करण्यापूर्वी रिलीज नोट्स वाचा आणि दोन्ही प्रकारे आधी डंप घ्या.
  • MariaDB नवीन व्हर्जनवर सर्व्हर आल्यानंतर mariadb-upgrade चालवण्याची अपेक्षा करते.
  • MongoDB एका वेळी एक मेजर व्हर्जन अपग्रेड करणे आवश्यक आहे आणि प्रत्येक टप्प्यानंतर पुढे जाण्यापूर्वी तुम्ही फिचर कंपॅटिबिलिटी व्हर्जन सेट करणे आवश्यक आहे. व्हर्जन वगळल्यास mongod सुरू होण्यास नकार देतो आणि featureCompatibilityVersion चे नाव असलेली UPGRADE PROBLEM ओळ लॉग करतो. MongoDB 7.0 पासून कमांडला स्पष्ट कन्फर्मेशन फ्लॅगची आवश्यकता असते: db.adminCommand({ setFeatureCompatibilityVersion: "8.0", confirm: true }).
  • Redis जुन्या स्नॅपशॉट फाईल्स आनंदाने लोड करते पण नवीन नाही, त्यामुळे अपग्रेड म्हणजे रीस्टार्ट आणि डाउनग्रेड करताना डेटा लोड होण्यास अपयश येऊ शकते.

सामान्य नियम: कंटेनर डाउनग्रेड करणे सोपे बनवतो आणि अपग्रेड करणे अधिक सोपे बनवत नाही.

माझा डेटाबेस कंटेनर एक्झिट कोड 137 सह का बंद होतो?

याचे कारण कर्नलचा आउट ऑफ मेमरी (OOM) किलर आहे, ज्याने या प्रक्रियेला थांबवले आहे. 137 हा आकडा 128 अधिक सिग्नल 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 फक्त चालू असलेले कंटेनर दाखवते, त्यामुळे मृत डेटाबेस आउटपुटमध्ये दिसत नाही. इन्स्पेक्ट कमांडची ओळ "OOMKilled": true असे वाचते आणि कर्नल लॉगमध्ये एक जुळणारी नोंद असते:

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

OOMKilled फक्त हे सांगते की OOM किलरने कंटेनरमधील एक प्रक्रिया थांबवली आहे. Memory cgroup out of memory हा प्रीफिक्स हे दर्शवतो की ही मर्यादा कंटेनरची स्वतःची होती. संपूर्ण होस्टवर मेमरी कमी पडल्यास Out of memory: Killed process अशी नोंद होते आणि अशा वेळी उपाय कंटेनरमध्ये नसून होस्टवर करावा लागतो.

यामागील कार्यपद्धती अनेकांना आश्चर्यचकित करते. कंटेनरच्या आत, free आणि /proc/meminfo अजूनही होस्टची एकूण मेमरी दर्शवतात आणि cgroup मर्यादा तो आकडा बदलत नाही. PostgreSQL यावरून कशाचाही आकार ठरवत नाही: shared_buffers डीफॉल्टनुसार 128MB असते आणि त्यापेक्षा मोठी कोणतीही किंमत तुम्ही किंवा ट्युनिंग गाईडने निवडलेली असते. MySQL चे innodb_buffer_pool_size देखील डीफॉल्टनुसार 128M असते. समस्या तेव्हा सुरू होते जेव्हा सेटिंग्ज मशीनच्या रिपोर्टनुसार ठरवल्या जातात. PostgreSQL चे स्वतःचे मार्गदर्शन सिस्टम मेमरीच्या 25% इतके shared_buffers सुरुवातीला ठेवण्यास सुचवते, त्यामुळे 16 GB होस्टवर 2 GB मर्यादेसह, तो नियम 4 GB देतो आणि होस्टवर कोणताही ताण येण्यापूर्वीच cgroup डेटाबेस बंद करतो. काही इंजिन्स आता डीफॉल्टसाठी मर्यादा वाचतात: MySQL 9.3 आणि त्यानंतरची आवृत्ती असे करते, आणि MongoDB जेव्हा शक्य असेल तेव्हा WiredTiger कॅशेसाठी याचा वापर करते. दोन्ही इंजिन्स सर्व गोष्टींसाठी याचा वापर करत नाहीत आणि MongoDB च्या स्वतःच्या दस्तऐवजानुसार हे डिटेक्शन अयशस्वी होऊ शकते. त्यामुळे फक्त मेमरी मर्यादा पुरेशी नाही. तुम्हाला डेटाबेसच्या उपलब्ध मेमरीबद्दल स्पष्ट माहिती देणे आवश्यक आहे:

  • PostgreSQL: shared_buffers सेट करा आणि work_mem कडे लक्ष द्या. work_mem प्रत्येक सॉर्ट किंवा हॅश ऑपरेशनसाठी लागू होते आणि प्रत्येक कनेक्शन एकाच वेळी अनेक ऑपरेशन्स चालवू शकते, त्यामुळे पन्नास कनेक्शनसाठी मोठी किंमत दिल्यास कंटेनर लोडवर असताना बंद पडण्याचे हे सामान्य कारण ठरते.
  • MySQL आणि MariaDB: innodb_buffer_pool_size सेट करा, जे डीफॉल्टनुसार 128M असते. 9.3 पूर्वीच्या MySQL मध्ये, कंटेनरमध्ये innodb_dedicated_server बंद ठेवा, कारण ते मशीनच्या मेमरीवरून बफर पूलचा आकार ठरवते, ज्याचा अर्थ येथे होस्टची मेमरी असा होतो. 9.3 पासून, MySQL कंटेनरच्या मर्यादा वाचते आणि innodb_dedicated_server त्यानुसार आकार ठरवते, परंतु स्पष्टपणे बफर पूल आकार सेट करणे हा अधिक खात्रीशीर पर्याय आहे.
  • MongoDB: WiredTiger कॅशेचा आकार स्पष्टपणे सेट करा. MongoDB शक्य असेल तेव्हा कंटेनरची मर्यादा वापरते (hostInfo हे memLimitMB म्हणून रिपोर्ट करते), परंतु त्याचे स्वतःचे दस्तऐवज इशारा देतात की काही प्रकरणांमध्ये हे अयशस्वी होऊ शकते आणि तुम्हाला --wiredTigerCacheSizeGB किंवा --wiredTigerCacheSizePct कंटेनरच्या मेमरी मर्यादेपेक्षा कमी सेट करण्यास सांगतात.
  • Redis: maxmemory डीफॉल्टनुसार अमर्यादित असते, त्यामुळे cgroup थांबवेपर्यंत Redis वाढत राहते. maxmemory कंटेनर मर्यादेपेक्षा कमी सेट करा आणि योग्य maxmemory-policy निवडा.

Postgres देखील या घटनेची नोंद स्वतःच्या बाजूने करते आणि लॉगमध्ये तुम्हाला या दोन ओळी आढळतील:

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

एक बॅकएंड बंद झाल्यामुळे इतर सर्व बॅकएंड्सना रीस्टार्ट करावे लागते, कारण शेअर केलेली मेमरी आता विसंगत असू शकते. तुमच्या ॲप्लिकेशनसाठी ही एक कनेक्शन स्टॉर्म आहे, शांत घटना नाही. Docker Compose मध्ये मेमरी मर्यादा सेट करणे हे mem_limit आणि deploy.resources फॉरमॅटमधील फरक आणि सिंटॅक्स स्पष्ट करते.

यातील काहीही होस्टवर अदृश्य होत नाही. ते फक्त हलते. cgroup नसल्यास, डेटाबेस बॉक्सवरील इतर सर्व गोष्टींशी स्पर्धा करतो आणि होस्टचा OOM किलर स्कोअरनुसार एकाला बळी ठरवतो, जो sshd देखील असू शकतो. डेटाबेस बंद करणारी मर्यादा हाताळणे, होस्टच्या OOM मुळे तुम्हाला सिस्टमबाहेर काढण्यापेक्षा अधिक सोपे असते.

बॅकअप: डेटाबेस डंप करा, बाहेर बॅकअप घ्या

चालू असलेल्या डेटाबेसची डेटा डिरेक्टरी कॉपी करून बॅकअप घेऊ नका. सर्व्हर डेटा लिहित असताना घेतलेली फाईल-लेव्हल कॉपी ही 'torn copy' असते आणि ती रिस्टोर करतानाच लक्षात येते.

दोन खात्रीशीर पद्धती आहेत: डेटाबेस चालू असताना त्याच्या स्वतःच्या टूलने डंप घ्या आणि त्या डंपचा बॅकअप घ्या, किंवा कंटेनर थांबवून व्हॉल्यूमची 'cold' कॉपी करा.

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 कमांडला टर्मिनल जोडू शकते आणि टर्मिनल लेयर आउटपुट स्ट्रीममध्ये कॅरेज रिटर्न्स (carriage returns) जोडते. यामुळे टेक्स्ट डंप रिस्टोर करताना विचित्र त्रुटी येतात आणि बायनरी डंप पूर्णपणे खराब होतो. बॅकअप घेताना हे शांतपणे अपयशी ठरते आणि महिनाभरानंतर रिस्टोर करताना मोठ्या त्रुटी निर्माण होतात.

--single-transaction मुळे mysqldump ला संपूर्ण सर्व्हर लॉक न करता InnoDB टेबल्सचा सुसंगत स्नॅपशॉट मिळतो.

या कमांड्स प्रत्येकी एक फाईल तयार करतात. ही बॅकअप सिस्टिम नाही: यात रिटेंशन (retention), ऑफ-बॉक्स कॉपी किंवा पडताळणी नसते. डंप डिरेक्टरी अशा टूलकडे सोपवा जे या तिन्ही गोष्टी करते, ज्यासाठी restic backups from a VPS वापरले जाते. /var/lib/docker/volumes चा नाही, तर /srv/backups चा बॅकअप घ्या.

त्यानंतर रिस्टोर करून पहा, कारण जो बॅकअप तुम्ही कधीही रिस्टोर केला नाही तो बॅकअप नसतो:

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 मध्ये प्रत्येक कमांड काय काढून टाकते, याचे सविस्तर वर्णन दिले आहे.
  • डेटाचे डंप्स (dumps) compose द्वारे व्यवस्थापित केल्या जाणाऱ्या व्हॉल्यूम्सच्या बाहेर, होस्ट पाथवर ठेवा.
  • ज्या स्टॅकमध्ये तुमचा महत्त्वाचा डेटा आहे, तिथे ट्रबलशूटिंग उत्तरातील -v कधीही पेस्ट करू नका.

डेटाबेस पोर्ट सार्वजनिक करू नका

ही ओळ तुमचा डेटाबेस सार्वजनिक इंटरनेटवर उघड करते:

    ports:
      - "5432:5432"

हे सर्व इंटरफेसेसवर बाइंड होते. Docker जेव्हा पोर्ट पब्लिश करते, तेव्हा ते फायरवॉलच्या इनपुट नियमांपर्यंत पोहोचण्यापूर्वीच पॅकेटचे डेस्टिनेशन बदलून टाकते. ufw चे नियम इनपुट चेनमध्ये असतात, त्यामुळे ufw deny 5432 चा काहीही उपयोग होत नाही. Docker पब्लिश केलेले पोर्ट ufw ला कसे बायपास करतात हे चेन ट्रॅव्हर्सल दर्शवते.

एकाच compose प्रोजेक्टमधील ॲप्लिकेशन डेटाबेसशी compose नेटवर्कवर सर्व्हिसच्या नावाने संपर्क साधू शकते, त्यामुळे त्याला पोर्ट पब्लिश करण्याची गरज नसते. हा ब्लॉक काढून टाका. जर तुम्हाला होस्टवरून क्लायंट वापरायचा असेल, तर फक्त लूपबॅकवर बाइंड करा:

    ports:
      - "127.0.0.1:5432:5432"

सध्या काय लिसन करत आहे ते तपासा:

sudo ss -ltnp | grep 5432

127.0.0.1:5432 हे तुम्हाला हवे असलेले आउटपुट आहे. 0.0.0.0:5432 चा अर्थ असा की कोणीही तुमच्या पासवर्डचा प्रयत्न करू शकते.

कुठे काय चालवावे

एका VPS वर एक ॲप्लिकेशन. कंटेनर वापरा. एका निश्चित नावासह (pinned name) नेमड व्हॉल्यूम वापरा, पोर्ट पब्लिश करू नका, मेमरी लिमिट सेट करा आणि त्यानुसार डेटाबेस सेटिंग्ज ठेवा. दररोज रात्री होणारा डंप होस्ट पाथवर घ्या, जो restic द्वारे गोळा केला जाईल. VPS वर क्लीन Docker इन्स्टॉल करण्यापासून सुरुवात करा आणि संपूर्ण स्टॅक एका compose फाईलमध्ये ठेवा जी तुम्ही git मध्ये कमिट कराल. याचा मोठा फायदा असा की, डेटाबेस व्हर्जन ही git मध्ये रिव्ह्यू करता येणारी एक ओळ बनते.

एका होस्टवर अनेक सेवा. कंटेनर वापरा, प्रत्येक ॲप्लिकेशनसाठी स्वतंत्र डेटाबेस ठेवा, सर्वांसाठी एकच सामायिक सर्व्हर वापरू नका. सामायिक सर्व्हरमुळे सर्व ॲप्लिकेशन्स एकाच अपग्रेड शेड्यूलशी बांधले जातात आणि एक चुकीची क्वेरी सर्वांच्या सेवेमध्ये व्यत्यय आणू शकते. प्रत्येक कंटेनरला स्वतःची मेमरी लिमिट द्या, जेणेकरून एखादी चुकीची क्वेरी फक्त संबंधित ॲप्लिकेशनपुरती मर्यादित राहील. अनेक लहान Postgres इन्स्टन्स वापरल्यास थोडी जास्त डिस्क लागते, पण समन्वयाचा त्रास खूप कमी होतो.

डेटाबेस हेच उत्पादन असेल तर. तो व्हेंडरच्या पॅकेज रिपॉझिटरीमधून होस्टवर चालवा किंवा मॅनेज्ड सर्व्हिसचा वापर करा. pg_upgrade ला एकाच वेळी बायनरीजच्या दोन्ही प्रमुख आवृत्त्या (major versions) इन्स्टॉल करण्याची आवश्यकता असते, जे पॅकेजेसद्वारे शक्य होते पण सिंगल-व्हर्जन इमेजमध्ये नाही. जेव्हा डेटाबेसचे मशीन आणि डिस्कवर पूर्ण नियंत्रण असते, तेव्हा रेप्लिकेशन आणि WAL (write ahead log) आर्काइव्हिंग वापरून पॉइंट-इन-टाइम रिकव्हरी करणे सोपे जाते. ज्या सिस्टिममुळे तुम्हाला पहाटे 03:00 वाजता अलर्ट येऊ शकतो, त्यासाठी नेहमी सुरक्षित आणि खात्रीशीर मार्ग निवडा.

ॲप्लिकेशन लहान असेल तर. सर्व्हर-आधारित डेटाबेस न वापरण्याचा विचार करा. एका VPS वर चालणाऱ्या सिंगल-रायटर वेब ॲप्लिकेशनसाठी VPS वर प्रॉडक्शनमध्ये SQLite वापरणे अनेकदा अधिक चांगले ठरते, जिथे बॅकअप म्हणजे फक्त एक फाईल असते आणि अपग्रेड पाथ म्हणजे लायब्ररीचे व्हर्जन असते.

FAQ

Docker मध्ये production database चालवणे सुरक्षित आहे का?

हो, एकाच सर्व्हरवर चालणाऱ्या ॲप्लिकेशन स्टॅकसाठी हे सुरक्षित आहे. कंटेनर ही Linux मधील namespaces आणि cgroups वापरणारी एक प्रक्रिया (process) असते. त्यामुळे volume mount केल्यास, database त्याच host filesystem वर डेटा लिहितो, ज्यावर तो पॅकेजद्वारे इन्स्टॉल केल्यावर लिहितो. यात धोके हे तांत्रिक कार्यक्षमतेपेक्षा व्यवस्थापनाशी संबंधित असतात: जसे की, नाव निश्चित नसलेले volume, चुकीच्या user id कडे मालकी असलेले bind mount, आणि तुम्ही कधीही न तपासलेला restore, तसेच docker compose down -v. या चार गोष्टींची काळजी घेतल्यास कंटेनर सुरक्षित राहतो. जेव्हा database हे मुख्य कार्यभार (workload) असते आणि तुम्हाला pg_upgrade, replication किंवा point in time recovery ची गरज असते, तेव्हा host वर थेट इन्स्टॉलेशन करणे योग्य ठरते.

Database डेटासाठी मी bind mount वापरावे की named volume?

जोपर्यंत तुम्हाला host path माहित असण्याचे काही विशिष्ट कारण नसेल, तोपर्यंत named volume वापरा. Docker स्वतः directory तयार करते आणि इमेजचा entrypoint पहिल्यांदा सुरू होताना मालकी (ownership) सेट करतो, त्यामुळे परवानगीच्या (permission) समस्या उद्भवत नाहीत. volume ला स्पष्ट name: ने निश्चित करा किंवा त्याला external: true म्हणून चिन्हांकित करा, अन्यथा प्रोजेक्ट डिरेक्टरीचे नाव बदलल्यास नकळत एक नवीन रिकामे volume आणि रिकामे database तयार होईल. जर तुम्ही host डिरेक्टरीची मालकी इमेज ज्या numeric user id वर चालते, त्याकडे (उदा. अधिकृत Postgres, MySQL आणि MongoDB इमेजसाठी 999, आणि Postgres -alpine टॅगसाठी 70) chown केली, तर bind mount वापरणे योग्य आहे. हे ls -ldn ने तपासा, कारण ls -l तुमच्या host वरील त्या नंबरसाठीचे नाव दाखवते आणि ते नाव कंटेनरच्या आत निरर्थक असते.

docker compose down -v काय डिलीट करते?

हे सामान्य down प्रमाणे कंटेनर आणि नेटवर्क काढून टाकते, आणि -v त्या compose फाईलमध्ये घोषित केलेले प्रत्येक named volume आणि त्या कंटेनरला जोडलेले प्रत्येक anonymous volume देखील काढून टाकते. यामध्ये database चा देखील समावेश होतो. यासाठी कोणतीही पुष्टी (confirmation) विचारली जात नाही आणि डेटा परत मिळवता येत नाही. external: true म्हणून चिन्हांकित केलेले volumes काढले जात नाहीत, म्हणूनच database volume ला external म्हणून चिन्हांकित करणे महत्त्वाचे आहे. नियमित रीस्टार्टसाठी docker compose stop आणि docker compose start वापरा.

Docker मध्ये PostgreSQL ला नवीन major version वर कसे अपग्रेड करावे?

Dump आणि restore करा. postgres:16 बदलून postgres:17 केल्यास आणि रीस्टार्ट केल्यास FATAL: database files are incompatible with server एरर येते, ज्यामध्ये DETAIL ओळ दोन्ही आवृत्त्यांची नावे दर्शवते, कारण नवीन बायनरीज जुन्या कॅटलॉग लेआउट वाचू शकत नाहीत. यामुळे काहीही खराब होत नाही: जुना टॅग परत लावल्यास ते पुन्हा सुरू होते. चालू असलेल्या जुन्या कंटेनरवर नवीन आवृत्तीचा क्लायंट वापरून pg_dumpall घ्या, फाईल PostgreSQL database cluster dump complete ने संपते याची खात्री करा, त्यानंतर नवीन टॅग रिकाम्या volume वर सुरू करा आणि dump लोड करा. postgres:18 पासून, ते volume /var/lib/postgresql/data ऐवजी /var/lib/postgresql वर mount करा. एकाच major version मधील minor अपग्रेडसाठी फक्त pull आणि restart पुरेसे असते.

माझा database कंटेनर कोड 137 सह का बंद होतो?

137 म्हणजे 128 अधिक सिग्नल 9, याचा अर्थ प्रक्रियेला थेट थांबवण्यात आले आहे. docker inspect <container> | grep -i oomkilled चालवा; true मूल्य म्हणजे OOM killer ने कंटेनरमधील प्रक्रिया थांबवली आहे, सहसा याचे कारण कंटेनरने स्वतःची cgroup मेमरी मर्यादा ओलांडणे हे असते. याचे सामान्य कारण म्हणजे host साठी ठरवलेली मेमरी सेटिंग्ज कंटेनरसाठी वापरणे: कंटेनरमधील टूल्स अजूनही host ची एकूण मेमरी दाखवतात, त्यामुळे 16 GB साठी बनवलेला बफर 2 GB मध्ये राहण्याचा प्रयत्न करतो. कंटेनरला दिलेल्या मर्यादेनुसार shared_buffers आणि work_mem, किंवा innodb_buffer_pool_size सेट करा. कर्नलने कोणती प्रक्रिया निवडली आणि ती कंटेनरची मर्यादा होती की host-wide Out of memory kill, हे तपासण्यासाठी journalctl -k मधील संबंधित Memory cgroup out of memory ओळ तपासा.

हा लेख उपयुक्त होता का?