SSD Nodes Learn Hosting plans →
கல்வி வழிகாட்டிகள் Matt Connorஆல் Matt Connor · புதுப்பிக்கப்பட்டது 2026-10-24

Database-ஐ Docker-ல் இயக்குவது பாதுகாப்பானதா?

Postgres, MySQL, MongoDB போன்றவற்றை Docker-ல் இயக்குவது production-க்கு ஏற்றது. Volumes, upgrades, backups மற்றும் memory limits ஆகியவற்றைச் சரியாகக் கையாள்வது அவசியம்.

Database-ஐ Docker-ல் இயக்க வேண்டுமா அல்லது host-ல் இயக்க வேண்டுமா?

Database-ஐ Docker-ல் இயக்குங்கள். ஒரு VPS-ல் ஒரு application stack-ஐ இயக்கும்போது, container-ஆக உள்ள PostgreSQL, MySQL, MongoDB அல்லது Redis ஆகியவை சாதாரணமான production தேர்வுகள் ஆகும். இதைப் பற்றிய விவாதங்கள் பெரும்பாலும் தவறான கோணத்திலேயே அமைகின்றன. Container என்பது Linux namespaces மற்றும் cgroups-ஆல் சூழப்பட்ட ஒரு process மட்டுமே; இது virtual machine அல்ல. எனவே, database-க்கும் disk-க்கும் இடையே hypervisor எதுவும் இல்லை. Bind mount அல்லது local named volume-ஐப் பயன்படுத்தும்போது, தரவுகள் நேரடியாக host filesystem-ல் எழுதப்படுகின்றன; இது package install மூலம் இயங்கும் database பயன்படுத்தும் அதே முறைதான்.

இதன் உண்மையான சவால் செயல்பாட்டு ரீதியானது (operational). இந்த அமைப்பு சிறப்பாகச் செயல்படுமா அல்லது சிக்கலாகுமா என்பதை நான்கு விஷயங்கள் தீர்மானிக்கின்றன: தரவுகள் எங்கே சேமிக்கப்படுகின்றன, அந்த directory-ன் உரிமையாளர் யார், major version upgrade எப்படிச் செய்யப்படுகிறது, மற்றும் நீங்கள் எப்போதாவது backup-ஐ restore செய்து பார்த்திருக்கிறீர்களா என்பது. இவற்றைச் சரியாகச் செய்துவிட்டால், container என்பது ஒரு சிறிய தொழில்நுட்ப விவரம் மட்டுமே. இவற்றைத் தவறவிட்டால், நீங்கள் container-ஐக் குறை சொல்ல நேரிடும்.

எந்தவொரு server database-க்கும் இதுவே பொருந்தும். கீழே உள்ள உதாரணங்கள் PostgreSQL, MySQL, MongoDB மற்றும் Redis ஆகியவற்றைப் பயன்படுத்துகின்றன. அந்தந்த product-க்குரிய முக்கிய வேறுபாடுகள் தேவைப்படும் இடங்களில் குறிப்பிடப்பட்டுள்ளன.

ஒரு container உண்மையில் எதை மாற்றுகிறது

நீங்கள் ஒரு volume-ஐ mount செய்யும் வரை, storage path மாறுவதில்லை. அதே kernel, அதே page cache, அதே filesystem தான் பயன்படுத்தப்படுகிறது.

செயல்திறனில் ஒரு முக்கியமான சிக்கல் உள்ளது; எதையும் mount செய்யாதபோது இது நிகழும். Volume இல்லையென்றால், தரவு அடைவு (data directory) container-ன் writable layer-ல் அமையும். இது image-க்கு மேல் அடுக்கப்பட்ட ஒரு overlay filesystem ஆகும். அங்கு செய்யப்படும் எழுதும் செயல்பாடுகள் (writes) மெதுவானவை, மேலும் container நீக்கப்படும்போது அந்த layer முழுவதுமே அழிந்துவிடும். "இன்று காலை என் database காலியாக இருந்தது" என்ற புகார்களுக்கு இதுவே காரணம்.

உண்மையில் மாறுபவை:

  • வாழ்க்கைச் சுழற்சி (Lifecycle). docker compose down கட்டளை container-ஐ அழித்துவிடும். Volume-ல் இல்லாத அனைத்தும் அதனுடன் அழிந்துவிடும்.
  • பதிப்பு (Version). Image tag தான் பதிப்பு. ஒரு database container-க்குள் நீங்கள் செய்யும் எந்த மாற்றமும் apt upgrade, அடுத்த docker compose pull-ஐத் தாண்டி நிலைத்திருக்காது.
  • நினைவகக் கணக்கீடு (Memory accounting). Cgroup limit என்பது kernel-ஆல் அமல்படுத்தப்படும் ஒரு கடினமான எல்லையாகும். பெரும்பாலான database-களின் default அமைப்புகள் தங்களை இந்த எல்லைக்கு ஏற்ப மாற்றிக்கொள்வதில்லை. MySQL 9.3 அல்லது அதற்குப் பிந்தைய பதிப்புகள் சில அமைப்புகளுக்காக இந்த எல்லையை வாசிக்கின்றன. MongoDB அதன் WiredTiger cache-க்காக இதைச் செய்ய முயல்கிறது, ஆனால் சில நேரங்களில் அது சரியாகச் செயல்படாது என்று அதன் ஆவணங்களே எச்சரிக்கின்றன. PostgreSQL மற்றும் Redis இதைச் செய்வதில்லை.
  • பயனர் (User). இந்தச் செயல்முறை (process) container-க்குள் ஒரு numeric user id-ஆக இயங்குகிறது. இது உங்கள் host-ல் எந்தக் கோப்பின் மீதும் உரிமை கொண்டிருக்காமல் இருக்கலாம்.

தரவு எங்கு சேமிக்கப்படுகிறது என்பதே அனைத்தையும் தீர்மானிக்கிறது

இதற்கு இரண்டு சிறந்த வழிகளும், ஒரு பொதுவான தவறும் உள்ளன.

  • Named volume: pgdata:/var/lib/postgresql/data. Docker, /var/lib/docker/volumes/<project>_pgdata/_data-ல் கோப்பகத்தை (directory) உருவாக்குகிறது, மேலும் முதல்முறை இயங்கும்போது image entrypoint அதற்கான உரிமையை (ownership) அமைக்கிறது. இதுவே இயல்பான தேர்வாகும்.
  • Bind mount: /srv/appname/pg:/var/lib/postgresql/data. பாதையை நீங்களே தேர்ந்தெடுப்பதால், அனுமதிகள் (permissions) தொடர்பான சிக்கல்களுக்கு நீங்களே பொறுப்பாவீர்கள்.
  • எந்த mount-ம் பயன்படுத்தாதது. மேலே உள்ளதைப் பார்க்கவும். தரவு container-க்குள்ளேயே இருக்கும்.

இதன் முழுமையான சாதக பாதகங்கள் தனி தலைப்பாகும், bind mounts மற்றும் named volumes ஒப்பீடு இதை விளக்குகிறது. தரவுத்தளத்தைப் பொறுத்தவரை சுருக்கமான அறிவுரை: host பாதையைத் தெரிந்துகொள்ள வேண்டிய குறிப்பிட்ட காரணம் இல்லையென்றால், named volume-ஐப் பயன்படுத்தவும். ஒருவேளை bind mount-ஐப் பயன்படுத்தினால், அதை git clean அணுகக்கூடிய project கோப்பகத்திற்குள் வைக்காமல், /srv/appname/pg போன்ற நிலையான இடத்தில் வைக்கவும்.

Network storage விஷயத்தில் கவனமாக இருக்கவும். NFS (network file system) அல்லது அதன் locking மற்றும் fsync செயல்பாட்டை நீங்கள் சோதிக்காத எந்தவொரு network mount-லும் தரவுத்தளத்தின் தரவுக் கோப்பகத்தை வைக்க வேண்டாம். PostgreSQL, NFS-க்கு ஒரு உறுதியான தேவையை ஆவணப்படுத்துகிறது: hard விருப்பத்தைப் பயன்படுத்தி mount செய்ய வேண்டும். மேலும், NFS server-ல் sync export விருப்பத்தைப் பயன்படுத்த கடுமையாகப் பரிந்துரைக்கிறது. ஏனெனில், அது இல்லையென்றால் client-ல் நடக்கும் fsync, server-ன் வட்டை (disk) சென்றடைவது உறுதி செய்யப்படாது. ஒரு வெற்றிகரமான fsync என்பது தரவுகள் நிலையான சேமிப்பகத்தில் (stable storage) பதிவாகிவிட்டதைக் குறிக்கும் என்று தரவுத்தளங்கள் கருதுகின்றன. இந்த அனுமானம் தவறாகும்போது, சில வாரங்கள் கழித்து தரவுச் சிதைவு (corruption) ஏற்படும்.

Volume பெயர் தொலைந்து போவதற்கு முன்பே அதை நிலைநிறுத்துங்கள் (Pin)

Compose ஒரு volume-க்கு <project>_<volume> என்று பெயரிடுகிறது, மேலும் project பெயர் இயல்பாகவே directory பெயராக அமைகிறது. எனவே, ஒரு volume-ன் அடையாளம் directory பெயரைச் சார்ந்துள்ளது; மக்கள் எந்தவித யோசனையுமின்றி மாற்றக்கூடிய ஒரு விஷயம் இது.

/srv/app-ஐ /srv/app-old-க்கு நகர்த்தினால், அல்லது compose file-ல் உள்ள pgdata key-ஐ மறுபெயரிட்டால், அடுத்தமுறை இயங்கும் docker compose up -d ஒரு புதிய காலி volume-ஐ உருவாக்கும். Postgres அதில் ஒரு புதிய cluster-ஐ initialize செய்யும். Container ஆரோக்கியமாக இருக்கும், application தொடங்கும், ஆனால் அனைத்து table-களும் அழிந்திருக்கும். பழைய volume இன்னும் பழைய பெயரிலேயே disk-ல் இருப்பதுதான் இதில் உள்ள ஒரே நல்ல செய்தி.

docker volume ls
docker volume inspect app_pgdata

இது நடக்காமல் இருக்க பெயர்களை நிலைநிறுத்துங்கள் (Pin). Project பெயர் மற்றும் volume பெயரைத் தெளிவாகக் குறிப்பிடுங்கள்:

name: myapp

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

volumes:
  pgdata:
    name: myapp_pgdata

ஏற்கனவே ஒரு stray volume-ல் உங்கள் தரவு இருந்தால், database-ஐ நிறுத்திவிட்டு அதை நகலெடுங்கள்:

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

Database இயங்கிக்கொண்டிருக்கும்போது நகலெடுத்தால், எழுதப்பட்டுக்கொண்டிருந்த கோப்புகள் சிதைந்த நிலையில் (torn copy) கிடைக்கும். எனவே முதலில் அதை நிறுத்துங்கள்.

தரவு அடைவின் (data directory) உரிமையாளர் யார்

அதிகாரப்பூர்வ Postgres, MySQL மற்றும் MongoDB images-கள் அவற்றின் server-ஐ ஒரு சலுகையற்ற numeric user id மூலம் இயக்குகின்றன: இயல்புநிலை tags-ல் 999, மற்றும் Postgres -alpine tags-ல் 70. Container root பயனராகத் தொடங்கும்போது, entrypoint தரவு அடைவின் உரிமையை அந்தப் பயனருக்கு மாற்றிவிட்டு, பின்னர் தனது சலுகைகளைக் குறைத்துக்கொள்ளும். இதனால்தான் ஒரு காலி bind mount பொதுவாக முதல் முயற்சியிலேயே வேலை செய்கிறது.

நீங்கள் compose கோப்பில் user:-ஐ அமைத்தவுடன் இது செயலிழந்துவிடும், ஏனெனில் அப்போது எதையும் சரிசெய்ய entrypoint-க்கு எந்தச் சலுகையும் இருக்காது. Postgres இதை நேரடியாகவே குறிப்பிடுகிறது:

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

தவறான mode-ல் இருக்கும் தரவு அடைவு வேறு ஒரு செய்தியைக் காட்டும். இதை அடையாளம் காண்பது அவசியம், ஏனெனில் இதற்கான தீர்வு 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-ம் இதே முறையில் உரிமையைச் சரிசெய்யும், எனவே இந்த lock file பிழை ஏற்பட்டால், அதால் உரிமையை மாற்ற முடியவில்லை என்று அர்த்தம்: பொதுவாக 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 அடைவின் உரிமையை ஒரு பெயருக்கு மாற்றாமல், அந்த numeric id-க்கு மாற்றுவதாகும்:

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 image-க்கு, அதற்குப் பதிலாக 70:70-ஐப் பயன்படுத்தவும், அப்போது 70 70-ஐ எதிர்பார்க்கலாம். உங்கள் host-ல் உள்ள postgres என்ற கணக்கிற்கும், image-க்குள் உள்ள postgres என்ற கணக்கிற்கும் எந்தத் தொடர்பும் இல்லை: kernel எண்களை மட்டுமே ஒப்பிடும், பெயர்கள் இருபுறமும் தனித்தனியாகவே பார்க்கப்படும். PUID மற்றும் PGID எவ்வாறு host பயனர்களை container-க்குள் இணைக்கிறது என்பது அந்த mapping-ஐ விரிவாக விளக்குகிறது. Rootless Docker அல்லது user namespace remapping-ன் கீழ் இந்த எண்கள் மீண்டும் மாறும், எனவே 999 என்று ஊகிப்பதற்குப் பதிலாக, இயங்கிக்கொண்டிருக்கும் container-லிருந்து ids-ஐச் சரிபார்க்கவும்.

Named volumes-ஐப் பயன்படுத்தினால், முதல்முறை இயக்கும்போது இந்தப் பகுதி தொடர்பான சிக்கல்கள் வராது, ஏனெனில் Docker ஒரு காலி அடைவை உருவாக்கி, entrypoint அதற்கு உரிமையாளராகிவிடும்.

மேம்படுத்தல்கள்: image tag மாற்றத்தின் மூலம் ஒரு package மேம்படுத்தல்

Host-ல், apt upgrade உங்களை ஒரு minor version-க்கு நகர்த்துகிறது. உங்கள் distribution தானாகவே database major version-ஐ மாற்றாது. நீங்கள் மாற்ற விரும்பும்போது, இரண்டு தொகுப்பு binary-களையும் ஒரே நேரத்தில் நிறுவ முடியும்; இதுதான் pg_upgrade-க்குத் தேவைப்படும் முறையாகும்.

Container-ல் tag என்பது version-ஐக் குறிக்கும், எனவே ஒரு மேம்படுத்தல் என்பது ஒரு வரியை மாற்றுவதாகும். இது minor மேம்படுத்தல்களை எளிதாக்குகிறது, ஆனால் major மேம்படுத்தல்கள் ஒரு தனி நடைமுறையாகும்.

postgres:16-ஐ postgres:17 என மாற்றி, docker compose up -d-ஐ இயக்கினால், container உடனடியாக நின்றுவிடும்:

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.

எந்த பாதிப்பும் ஏற்படாது. புதிய binary-கள் பழைய disk-ல் உள்ள catalog layout-ஐ வாசிக்க மறுக்கும், ஏனெனில் major version-களுக்கு இடையே இது மாறுகிறது. tag-ஐ மீண்டும் postgres:16 என மாற்றினால் அது மீண்டும் இயங்கும். இந்த rollback வசதியே container-கள் வழங்கும் உண்மையான மேம்படுத்தல் நன்மையாகும்.

இதற்கான அங்கீகரிக்கப்பட்ட வழி dump மற்றும் restore ஆகும். புதிய client மூலம் dump எடுப்பதே PostgreSQL-க்கு விருப்பமானது, எனவே 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

கோப்பின் அளவு குறைந்தது பத்து கிலோபைட்டுகளாக இருக்க வேண்டும் மற்றும் அதன் கடைசி வரி PostgreSQL database cluster dump complete என முடிய வேண்டும். சில நூறு பைட்டுகள் மட்டுமே இருந்தால், dump தோல்வியடைந்துள்ளது என்று அர்த்தம்; வீணாக volume-ஐ நீக்கிவிடாதீர்கள். அந்தச் சரிபார்ப்புக்குப் பிறகு மட்டுமே:

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-வது பதிப்பிலிருந்து, அதிகாரப்பூர்வ image அதன் தரவுகளை /var/lib/postgresql-க்குக் கீழ் உள்ள versioned directory-ல் (18-க்கு, /var/lib/postgresql/18/docker) வைத்திருக்கும் மற்றும் அதன் volume-ஐ /var/lib/postgresql-ல் அறிவிக்கும். இன்னும் /var/lib/postgresql/data-ல் mount செய்யப்பட்டிருக்கும் volume, Error: in 18+, these Docker images are configured to store database data எனத் தொடங்கும் பிழையுடன் container-ஐ நிறுத்திவிடும். நீங்கள் 18 அல்லது அதற்கு மேற்பட்ட பதிப்பிற்கு மாறும்போது, mount-ஐ pgdata:/var/lib/postgresql என மாற்றவும். இந்தப் பதிவில் உள்ள /var/lib/postgresql/data பாதைகள் 17 மற்றும் அதற்கு முந்தைய பதிப்புகளுக்கானவை.

பிற engine-களின் செயல்பாடுகள் மாறுபடும்:

  • MySQL 8 தொடக்கத்திலேயே அதன் data dictionary-ஐ மேம்படுத்திக்கொள்ளும், எனவே minor tag மாற்றம் பொதுவாக ஒரு restart மட்டுமே. release series-களுக்கு இடையே மாறுவதற்கு முன் release notes-ஐப் படிக்கவும், எப்படியிருந்தாலும் முதலில் dump எடுக்கவும்.
  • MariaDB புதிய பதிப்பில் server இயங்கிய பிறகு mariadb-upgrade இயக்கப்பட வேண்டும் என்று எதிர்பார்க்கிறது.
  • MongoDB-ஐ ஒரு நேரத்தில் ஒரு major version ஆகத்தான் மேம்படுத்த வேண்டும், ஒவ்வொரு படிக்குப் பிறகும் அடுத்த நிலைக்குச் செல்லும் முன் feature compatibility version-ஐ அமைக்க வேண்டும். ஒரு version-ஐத் தவிர்த்தால், mongod தொடங்க மறுக்கும் மற்றும் featureCompatibilityVersion-ஐக் குறிப்பிடும் UPGRADE PROBLEM வரியை log-ல் காட்டும். MongoDB 7.0-லிருந்து, இந்த command-க்கு ஒரு தெளிவான உறுதிப்படுத்தல் flag தேவை: db.adminCommand({ setFeatureCompatibilityVersion: "8.0", confirm: true }).
  • Redis பழைய snapshot கோப்புகளைச் சிரமமின்றி ஏற்கும், ஆனால் புதியவற்றை ஏற்காது. எனவே, மேம்படுத்தல் என்பது ஒரு restart ஆகும், மேலும் downgrade செய்யும்போது தரவுகள் ஏற்றப்படாமல் போகலாம்.

பொதுவான விதி: container-கள் downgrade செய்வதை எளிதாக்குகின்றன, ஆனால் மேம்படுத்தலை எளிதாக்குவதில்லை.

எனது database container ஏன் exit code 137-உடன் முடிகிறது?

kernel-ன் out of memory (OOM) killer அதை நிறுத்தியதே இதற்குக் காரணம். 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 இயங்கிக்கொண்டிருக்கும் container-களை மட்டுமே பட்டியலிடும், எனவே செயலிழந்த database வெளியீட்டில் இருக்காது. inspect வரியானது "OOMKilled": true என்று வாசிக்கும், மேலும் kernel log-ல் அதற்கு இணையான பதிவு இருக்கும்:

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

OOMKilled, container-ல் உள்ள ஒரு process-ஐ OOM killer முடித்துவிட்டது என்பதை மட்டுமே உங்களுக்குத் தெரிவிக்கும். Memory cgroup out of memory முன்னொட்டுதான் அது container-ன் சொந்த வரம்பு என்பதை உறுதிப்படுத்துகிறது. host முழுமைக்குமான பற்றாக்குறை ஏற்பட்டால் Out of memory: Killed process என்று பதிவாகும், அப்போது தீர்வை container-ல் அல்ல, host-ல் செய்ய வேண்டும்.

இதன் பின்னணியில் உள்ள செயல்முறை பலரை ஆச்சரியப்படுத்தும். container-க்குள், free மற்றும் /proc/meminfo ஆகியவை host-ன் மொத்த நினைவகத்தையே காட்டும், cgroup வரம்பு அந்த எண்ணை மாற்றாது. PostgreSQL இதிலிருந்து எதையும் கணக்கிடுவதில்லை: shared_buffers இயல்பாக 128MB என இருக்கும், அதைவிட அதிகமான மதிப்பை நீங்களோ அல்லது ஒரு tuning வழிகாட்டியோதான் தேர்வு செய்திருப்பீர்கள். MySQL-ன் innodb_buffer_pool_size-ம் இயல்பாக 128M என்றே இருக்கும். கணினி காட்டும் அளவை வைத்து அமைப்புகளை மாற்றும்போதுதான் சிக்கல் தொடங்குகிறது. PostgreSQL-ன் சொந்த வழிகாட்டுதல், system நினைவகத்தில் 25%-ஐ ஆரம்ப shared_buffers-ஆகப் பயன்படுத்தப் பரிந்துரைக்கிறது. எனவே, 2 GB வரம்பு கொண்ட 16 GB host-ல், அந்த விதி 4 GB-ஐக் கொடுக்கும், இதனால் host-ல் எந்த அழுத்தமும் இல்லாதபோதே cgroup database-ஐக் கொன்றுவிடும். சில engines இப்போது வரம்புகளைப் படிக்கின்றன: MySQL 9.3 மற்றும் அதற்குப் பிந்தைய பதிப்புகள் அவ்வாறு செய்கின்றன, MongoDB-யால் கண்டறிய முடிந்தால் WiredTiger cache-க்கு அதைப் பயன்படுத்துகிறது. ஆனால் அவை அனைத்தையும் அதிலிருந்து கணக்கிடுவதில்லை, மேலும் கண்டறிதல் தோல்வியடையலாம் என்று MongoDB-ன் ஆவணங்களே கூறுகின்றன. எனவே, நினைவக வரம்பு மட்டும் போதாது. database-க்கு அதன் வசதி என்ன என்பதை நீங்கள் தெளிவாகக் கூற வேண்டும்:

  • PostgreSQL: shared_buffers-ஐ அமைக்கவும், work_mem-ல் கவனம் செலுத்தவும். work_mem ஒவ்வொரு sort அல்லது hash செயல்பாட்டிற்கும் பொருந்தும், ஒவ்வொரு இணைப்பும் ஒரே நேரத்தில் பலவற்றை இயக்கலாம். எனவே, அதிகப்படியான மதிப்பை 50 இணைப்புகளுடன் பெருக்கும்போது, சுமை அதிகரிக்கும்போது container செயலிழக்க இதுவே பொதுவான காரணமாகிறது.
  • MySQL மற்றும் MariaDB: innodb_buffer_pool_size-ஐ அமைக்கவும், இது இயல்பாக 128M என இருக்கும். 9.3-க்கு முந்தைய MySQL-ல், container-க்குள் innodb_dedicated_server-ஐத் தவிர்க்கவும், ஏனெனில் அது machine-ன் நினைவகத்தை (அதாவது host-ன் நினைவகம்) அடிப்படையாகக் கொண்டு buffer pool-ஐ அமைக்கும். 9.3 முதல், MySQL container-ன் வரம்புகளைப் படித்து innodb_dedicated_server-ஐ அமைக்கும், இருப்பினும் buffer pool அளவை நீங்களே குறிப்பிடுவதுதான் பாதுகாப்பானது.
  • MongoDB: WiredTiger cache அளவை நீங்களே குறிப்பிடவும். MongoDB-யால் கண்டறிய முடிந்தால் container-ன் வரம்பைப் பயன்படுத்தும் (hostInfo அதை memLimitMB என காட்டும்), ஆனால் சில சமயங்களில் இது தோல்வியடையலாம் என அதன் ஆவணங்கள் எச்சரிக்கின்றன. எனவே --wiredTigerCacheSizeGB அல்லது --wiredTigerCacheSizePct-ஐ container-ன் நினைவக வரம்பிற்குள் அமைக்கவும்.
  • Redis: maxmemory இயல்பாக வரம்பற்றது, எனவே cgroup அதை நிறுத்தும் வரை Redis வளர்ந்துகொண்டே இருக்கும். maxmemory-ஐ container வரம்பிற்குள் வசதியாக அமைக்கவும் மற்றும் ஒரு maxmemory-policy-ஐத் தேர்வு செய்யவும்.

Postgres இந்த நிகழ்வை அதன் பக்கத்திலிருந்தும் பதிவு செய்யும், log-ல் நீங்கள் இந்த இரண்டு வரிகளைக் காண்பீர்கள்:

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 கொல்லப்பட்டால், அது மற்ற அனைத்து backend-களையும் மறுதொடக்கம் செய்யத் தூண்டும், ஏனெனில் shared memory சீரற்றதாக மாறியிருக்கலாம். இது உங்கள் application-க்கு ஒரு connection storm-ஐ உருவாக்கும், இது சாதாரண நிகழ்வு அல்ல. Docker Compose-ல் நினைவக வரம்புகளை அமைத்தல் என்பது இதற்கான syntax மற்றும் mem_limit மற்றும் deploy.resources வடிவங்களுக்கு இடையிலான வேறுபாட்டை விளக்குகிறது.

இவை எதுவும் host-ல் மறைந்துவிடாது, இடம் மாறும். cgroup இல்லையென்றால், database மற்ற அனைத்து process-களுடனும் போட்டியிடும். host OOM killer ஒரு மதிப்பெண் அடிப்படையில் ஒரு victim-ஐத் தேர்ந்தெடுக்கும், அது sshd-ஆகக்கூட இருக்கலாம். database-ஐ முன்கூட்டியே நிறுத்தும் ஒரு வரம்பு, உங்களை வெளியேற்றும் host OOM-ஐ விட நிர்வகிக்க எளிதானது.

Backups: உள்ளே dump செய்யுங்கள், வெளியே backup எடுங்கள்

இயங்கிக்கொண்டிருக்கும் database-ன் data directory-ஐ அப்படியே நகலெடுப்பதன் மூலம் backup எடுக்காதீர்கள். server தரவுகளை எழுதிக்கொண்டிருக்கும்போது எடுக்கப்படும் file-level நகல், 'torn copy' எனப்படும் முழுமையற்ற நகலாக இருக்கும்; இதை நீங்கள் restore செய்ய முயலும்போதுதான் அறிவீர்கள்.

இதற்கு இரண்டு முறையான வழிகள் உள்ளன: database இயங்கும்போது அதன் சொந்த கருவியைப் பயன்படுத்தி dump எடுத்து அந்த dump-ஐ backup செய்வது, அல்லது container-ஐ நிறுத்திவிட்டு volume-ஐ 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 கட்டளையுடன் terminal-ஐ இணைக்கக்கூடும்; அவ்வாறு இணைந்தால், terminal layer வெளியீட்டு ஓட்டத்தில் (output stream) carriage returns-ஐச் சேர்க்கும். இதனால் text dump-ஐ restore செய்யும்போது விசித்திரமான பிழைகள் ஏற்படும், binary dump முற்றிலும் சிதைந்துவிடும். இது backup எடுக்கும்போது அமைதியாகத் தோல்வியடைந்து, ஒரு மாதம் கழித்து restore செய்யும்போது பெரிய சிக்கலை உண்டாக்கும்.

--single-transaction, முழு server-ஐயும் lock செய்யாமல் InnoDB tables-ன் சீரான snapshot-ஐ mysqldump-க்கு வழங்குகிறது.

இந்தக் கட்டளைகள் ஒவ்வொன்றும் ஒரு கோப்பை மட்டுமே உருவாக்குகின்றன. இவை backup அமைப்பு அல்ல: இதில் retention கிடையாது, off-box நகல் கிடையாது, சரிபார்ப்பும் (verification) கிடையாது. இந்த மூன்றையும் செய்யும் ஒரு கருவியிடம் dump directory-ஐ ஒப்படையுங்கள்; அதற்காகத்தான் restic backups from a VPS உள்ளது. /var/lib/docker/volumes-ஐ அல்ல, /srv/backups-ஐ backup எடுங்கள்.

பிறகு restore செய்து பாருங்கள், ஏனெனில் நீங்கள் ஒருமுறை கூட restore செய்யாத backup, backup-ஆகவே கருதப்படாது:

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 உங்கள் application-ன் tables-ஐப் பட்டியலிட வேண்டும். முடிவு காலியாக இருந்தாலோ அல்லது Did not find any relations. என்று வந்தாலோ, dump நீங்கள் நினைத்தது போல இல்லை என்று அர்த்தம். முடித்தவுடன் restore_test-ஐ நீக்கிவிடுங்கள்.

அனைத்தையும் நீக்கும் கட்டளை

docker compose down -v.

எளிமையான down கட்டளையானது containers மற்றும் network-ஐ நீக்கும். -v கட்டளையானது, அந்த compose கோப்பில் குறிப்பிடப்பட்டுள்ள அனைத்து named volumes மற்றும் அந்த containers-உடன் இணைக்கப்பட்டுள்ள அனைத்து anonymous volumes-ஐயும் நீக்கிவிடும். இதற்கு எந்த உறுதிப்படுத்தலும் (prompt) கேட்கப்படாது, இதைத் திரும்பப் பெறவும் (undo) முடியாது. சுய-வழங்கி (self-hosted) தரவுத்தளங்கள் அழிக்கப்படுவதற்கு இதுவே பொதுவான வழியாகும். பெரும்பாலும், ஏதோ ஒரு சிக்கலைத் தீர்க்க முயற்சிக்கும்போது, இணையதள மன்றங்களில் கொடுக்கப்பட்ட ஆலோசனையைப் பின்பற்றி இதை இயக்குவதால் இத்தகைய இழப்பு ஏற்படுகிறது.

பாதிப்பின் அளவைக் குறைக்க நான்கு வழிமுறைகள் உள்ளன:

  • தரவுத்தள volume-ஐ external: true என அறிவிக்கவும். Compose தனது கட்டுப்பாட்டில் இல்லாத volume-ஐ நீக்காது, எனவே -v கட்டளையால் அதை அணுக முடியாது. இதை docker volume create myapp_pgdata கட்டளையைப் பயன்படுத்தி ஒருமுறை உருவாக்கிக்கொள்ளலாம்.
  • வழக்கமான மறுதொடக்கங்களுக்கு (routine restarts) docker compose stop மற்றும் docker compose start கட்டளைகளைப் பயன்படுத்தவும். Compose-ல் down மற்றும் stop இடையிலான வேறுபாடு ஒவ்வொன்றும் எதை நீக்கும் என்பதை விளக்குகிறது.
  • தரவுத்தள dump கோப்புகளை, compose நிர்வகிக்கும் volumes-க்கு வெளியே உள்ள host path-ல் சேமித்து வைக்கவும்.
  • நீங்கள் முக்கியமாகக் கருதும் தரவுகளைக் கொண்ட stack-ல், சிக்கலைத் தீர்க்கும் மன்றங்களில் கொடுக்கப்படும் -v கட்டளையை ஒருபோதும் நகலெடுத்து இயக்க வேண்டாம்.

Database port-ஐ பொதுவெளியில் வெளியிட வேண்டாம்

இந்த வரி உங்கள் database-ஐ பொது இணையத்தில் வைக்கிறது:

    ports:
      - "5432:5432"

இது அனைத்து interface-களிலும் பிணைக்கப்படுகிறது (bind). Docker ஒரு port-ஐ வெளியிடும்போது, உங்கள் firewall-ன் input விதிகள் பார்ப்பதற்கு முன்பே packet-ன் இலக்கை மாற்றிவிடுகிறது. ufw விதிகள் input chain-ல் இருப்பதால், ufw deny 5432 எந்தப் பயனும் தராது. Docker published ports ஏன் ufw-ஐத் தவிர்க்கின்றன என்பது chain traversal-ஐ விளக்குகிறது.

ஒரே compose project-ல் உள்ள ஒரு application, compose network-ல் உள்ள service name மூலம் database-ஐ அணுகும். எனவே, அதற்கு port-ஐ வெளியிட வேண்டிய அவசியமில்லை. அந்த block-ஐ நீக்கிவிடவும். host-ல் உள்ள ஒரு client-க்கு அணுகல் தேவைப்பட்டால், 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-ல் ஒரு application. Container-ஐப் பயன்படுத்தவும். ஒரு குறிப்பிட்ட பெயரைக் கொண்ட named volume, திறக்கப்படாத port, database அமைப்புகளுக்கு ஏற்ப memory limit, மற்றும் restic மூலம் சேகரிக்கப்படும் nightly dump ஆகியவற்றை அமைக்கவும். VPS-ல் சுத்தமான Docker நிறுவல் என்பதிலிருந்து தொடங்கி, உங்கள் stack-ஐ ஒரே compose file-ல் வைத்து commit செய்யவும். இதன் நன்மை உண்மையானது: database version-ஐ git-ல் சரிபார்க்கக்கூடிய ஒரு வரியாக மாற்றலாம்.

பல சேவைகளை இயக்கும் ஒரு host. Containers-ஐப் பயன்படுத்தவும்; அனைத்துக்கும் ஒரே server-ஐப் பயன்படுத்தாமல், ஒவ்வொரு application-க்கும் ஒரு database-ஐத் தனித்தனியாக வைத்திருக்கவும். ஒரு shared server அனைத்து application-களையும் ஒரே upgrade கால அட்டவணையுடன் பிணைக்கிறது, மேலும் ஒரு runaway query அனைவரின் சேவையையும் முடக்கக்கூடும். ஒவ்வொரு container-க்கும் தனித்தனி memory limit-ஐ வழங்கவும், இதனால் ஒரு தவறான query அந்த application-க்குள்ளேயே கட்டுப்படுத்தப்படும். பல சிறிய Postgres instances-க்குச் சற்று கூடுதல் disk தேவைப்படும், ஆனால் ஒருங்கிணைப்பு மிகக் குறைவாகவே இருக்கும்.

Database-தான் தயாரிப்பு. அதை vendor-ன் package repository-லிருந்து host-ல் இயக்கவும் அல்லது managed service-க்குக் கட்டணம் செலுத்தவும். pg_upgrade-க்கு ஒரே நேரத்தில் இரண்டு major version binaries-ம் நிறுவப்பட்டிருக்க வேண்டும்; இது packages மூலம் கிடைக்கும், ஆனால் single-version image-ல் கிடைக்காது. Database அந்த machine மற்றும் அதன் disk-களைக் கட்டுப்படுத்தும்போது, replication மற்றும் WAL (write ahead log) archiving மூலம் point in time recovery செய்வது எளிது. அதிகாலையில் 03:00 மணிக்கு உங்களை எழுப்பும் (page) ஒரு system-க்கு, சலிப்பான ஆனால் பாதுகாப்பான வழியைத் தேர்ந்தெடுக்கவும்.

Application சிறியது. server database எதையும் இயக்காமல் இருப்பதைச் சிந்தியுங்கள். ஒரு VPS-ல் இயங்கும் single-writer web application-க்கு பெரும்பாலும் VPS-ல் production-ல் SQLite பயன்படுத்துவது சிறந்தது; இதில் backup என்பது ஒரே ஒரு file மட்டுமே, மேலும் upgrade என்பது ஒரு library version-ஐ மாற்றுவது மட்டுமே.

FAQ

production database-ஐ Docker-ல் இயக்குவது பாதுகாப்பானதா?

ஆம், ஒரே server-ல் இயங்கும் application stack-க்கு இது பாதுகாப்பானது. ஒரு container என்பது Linux namespaces மற்றும் cgroups மூலம் சூழப்பட்ட ஒரு process ஆகும். எனவே, volume mount செய்யும்போது, ஒரு package மூலம் நிறுவும் அதே host filesystem-ல் தான் database-ம் தரவுகளை எழுதுகிறது. இதில் உள்ள அபாயங்கள் செயல்பாட்டு ரீதியானவை, வேகத்தைப் பற்றியவை அல்ல: பெயரிடப்படாத volume, தவறான user id-ல் உள்ள bind mount, நீங்கள் ஒருபோதும் சோதிக்காத restore, மற்றும் docker compose down -v. இந்த நான்கையும் சரிசெய்துவிட்டால் container பாதுகாப்பானது. database தான் முதன்மையான பணிச்சுமை (workload) என்றும், உங்களுக்கு pg_upgrade, replication அல்லது point in time recovery தேவைப்படும்போதும் host-ல் நேரடியாக நிறுவுவது சிறந்தது.

database தரவுகளுக்கு bind mount-ஐ பயன்படுத்த வேண்டுமா அல்லது named volume-ஐயா?

host path-ஐ நீங்கள் குறிப்பாகத் தெரிந்து வைத்திருக்க வேண்டிய அவசியம் இல்லையென்றால், named volume-ஐப் பயன்படுத்தவும். Docker அந்த directory-ஐ உருவாக்கி, முதல்முறை தொடங்கும்போதே image entrypoint உரிமையாளரை (ownership) அமைத்துவிடும், எனவே அனுமதி (permission) தொடர்பான சிக்கல்கள் வராது. volume-ஐ ஒரு தெளிவான name: மூலம் இணைக்கவும் அல்லது external: true எனக் குறிப்பிடவும்; இல்லையெனில், project directory-ன் பெயரை மாற்றும்போது, அது அமைதியாக ஒரு புதிய காலி volume-ஐ உருவாக்கி, database-ஐ காலியாக்கிவிடும். image இயங்கும் numeric user id-க்கு host directory-ஐ chown செய்தால் bind mount-ஐப் பயன்படுத்தலாம். அதிகாரப்பூர்வ Postgres, MySQL மற்றும் MongoDB image-களின் default tag-களுக்கு இது 999, மற்றும் Postgres -alpine tag-களுக்கு இது 70 ஆகும். இதை ls -ldn மூலம் சரிபார்க்கவும், ஏனெனில் ls -l அந்த எண்ணிற்கான உங்கள் host-ன் பெயரை மட்டுமே காட்டும், அந்தப் பெயர் container-க்குள் அர்த்தமற்றது.

docker compose down -v எதை நீக்குகிறது?

இது ஒரு சாதாரண down போலவே container-களையும் network-ஐயும் நீக்குகிறது. ஆனால் -v, compose file-ல் அறிவிக்கப்பட்ட அனைத்து named volume-களையும், அந்த container-களுடன் இணைக்கப்பட்ட அனைத்து anonymous volume-களையும் கூடுதலாக நீக்கிவிடும். இதில் database-ம் அடங்கும். இதற்கு உறுதிப்படுத்தல் (confirmation) கேட்கப்படாது, தரவுகளை மீட்டெடுக்கவும் முடியாது. external: true எனக் குறிக்கப்பட்ட volume-கள் நீக்கப்படாது; database volume-ஐ external எனக் குறிப்பதற்கு இதுவே முக்கிய காரணம். வழக்கமான restart-க்கு docker compose stop மற்றும் docker compose start-ஐப் பயன்படுத்தவும்.

Docker-ல் PostgreSQL-ஐ புதிய major version-க்கு எப்படி upgrade செய்வது?

Dump மற்றும் restore செய்யவும். postgres:16-ஐ postgres:17 என மாற்றி restart செய்தால், DETAIL வரியுடன் FATAL: database files are incompatible with server பிழை வரும், ஏனெனில் புதிய binaries பழைய catalog அமைப்பை வாசிக்காது. எந்த பாதிப்பும் ஏற்படாது: பழைய tag-ஐ மீண்டும் மாற்றினால் அது இயங்கும். இயங்கும் பழைய container-க்கு எதிராக புதிய version-ன் client-ஐப் பயன்படுத்தி pg_dumpall எடுக்கவும், கோப்பு PostgreSQL database cluster dump complete-ல் முடிகிறதா என உறுதிப்படுத்தவும், பின்னர் புதிய tag-ஐ காலி volume-ல் தொடங்கி dump-ஐ ஏற்றவும். postgres:18-லிருந்து, அந்த volume-ஐ /var/lib/postgresql/data-க்கு பதிலாக /var/lib/postgresql-ல் mount செய்யவும். ஒரு major version-க்குள் நடக்கும் minor upgrade-களுக்கு pull செய்து restart செய்தால் போதுமானது.

எனது database container ஏன் code 137-ல் வெளியேறுகிறது?

137 என்பது 128 மற்றும் signal 9-ன் கூடுதல், எனவே ஏதோ ஒன்று அந்த process-ஐ உடனடியாகக் கொன்றுவிட்டது. docker inspect <container> | grep -i oomkilled-ஐ இயக்கவும்; true என்ற மதிப்பு இருந்தால், OOM killer அந்த container-ல் உள்ள process-ஐ முடித்துவிட்டது என்று அர்த்தம். பொதுவாக container அதன் சொந்த cgroup memory வரம்பை எட்டும்போது இது நடக்கும். container-க்கு பதிலாக host-ன் அளவீடுகளைப் பயன்படுத்துவதே இதற்கு முக்கிய காரணம்: container-க்குள் இருக்கும் கருவிகள் host-ன் மொத்த memory-ஐயே காட்டும், எனவே 16 GB-க்கு அமைக்கப்பட்ட buffer, 2 GB-க்குள் இயங்க முயன்று தோல்வியடையும். container-க்கு நீங்கள் கொடுத்த வரம்பிற்கு ஏற்ப shared_buffers மற்றும் work_mem அல்லது innodb_buffer_pool_size-ஐ அமைக்கவும். kernel எந்த process-ஐத் தேர்ந்தெடுத்தது என்பதையும், அது container-ன் வரம்புதானா அல்லது host-wide Out of memory கொலையா என்பதையும் உறுதிப்படுத்த journalctl -k-ல் உள்ள Memory cgroup out of memory வரியைச் சரிபார்க்கவும்.

இந்தக் கட்டுரை பயனுள்ளதாக இருந்ததா?