SSD Nodes Learn Hosting plans →
Mga Gabay Matt ConnorNi Matt Connor · Na-update 2026-10-24

Database sa Docker o sa Host: Alin ang Mas Tama?

Alamin kung bakit puwede ang PostgreSQL, MySQL, MongoDB, at Redis sa Docker production, at paano iwasan ang panganib sa volumes, upgrades, backups, at memory limits.

Dapat bang tumakbo ang database sa Docker o sa host?

Patakbuhin ang database sa Docker. Para sa isang application stack sa isang VPS, karaniwang production choice ang containerised PostgreSQL, MySQL, MongoDB, o Redis. Kadalasan, mali ang batayan ng pagtatalo tungkol dito. Ang container ay isang Linux process na may namespaces at cgroups sa paligid nito, hindi isang virtual machine. Kaya walang hypervisor sa pagitan ng database at ng disk. Sa bind mount o local named volume, sa host filesystem napupunta ang mga read at write. Ito rin ang filesystem na gagamitin ng package install.

Ang tunay na gastos ay nasa operasyon. Apat na bagay ang tumutukoy kung maayos ang setup na ito o mauuwi sa mabagal na disaster: kung saan naka-store ang data, kung sino ang may-ari ng directory na iyon, kung paano isasagawa ang major version upgrade, at kung nakapag-restore ka na ba ng backup. Kapag tama ang mga ito, detalye na lamang ang container. Kapag mali, ang container ang malamang mong sisihin.

Pareho ang desisyong ito para sa bawat server database. Gagamit ang mga halimbawa sa ibaba ng PostgreSQL, MySQL, MongoDB, at Redis. Ilalahad ang mga pagkakaiba ayon sa produkto kung mahalaga ang mga ito.

Ano talaga ang binabago ng isang container

Hindi ang storage path, basta nag-mount ka ng isa. Pareho pa rin ang kernel, page cache, at filesystem.

May isang tunay na performance trap: kapag wala kang anumang mina-mount. Kapag walang volume, napupunta ang data directory sa writable layer ng container, na isang overlay filesystem na naka-stack sa image. Mas mabagal ang mga write roon, at dine-delete ang buong layer kapag inalis ang container. Diyan nanggagaling ang sitwasyong “walang laman ang database ko kaninang umaga.”

Ang mga talagang nagbabago:

  • Ang lifecycle. Sinisira ng docker compose down ang container. Kasama nitong mawawala ang anumang wala sa isang volume.
  • Ang version. Ang image tag ang version. Walang apt upgrade sa loob ng database container na mananatili pagkatapos ng susunod na docker compose pull.
  • Ang memory accounting. Ang cgroup limit ay isang hard wall na ipinapatupad ng kernel, at karamihan sa mga default ng database ay hindi nag-a-adjust batay rito. Binabasa ng MySQL 9.3 o mas bago ang limit para sa ilang setting. Sinusubukan itong gawin ng MongoDB para sa WiredTiger cache nito, pero nagbababala ang sarili nitong documentation na maaaring hindi ito magawa sa ilang sitwasyon. Hindi ito ginagawa ng PostgreSQL at Redis.
  • Ang user. Tumatakbo ang process bilang numeric user id sa loob ng container, at maaaring wala itong pagmamay-ari sa host mo.

Kung saan naka-store ang data ang tumutukoy sa lahat

May dalawang maayos na opsyon at isang karaniwang pagkakamali.

  • Isang named volume: pgdata:/var/lib/postgresql/data. Awtomatikong ginagawa ng Docker ang directory sa /var/lib/docker/volumes/<project>_pgdata/_data, at itinatakda ng image entrypoint ang ownership sa unang run. Ito ang default na sagot.
  • Isang bind mount: /srv/appname/pg:/var/lib/postgresql/data. Ikaw ang pumipili ng path, kaya ikaw ang may pananagutan sa permissions.
  • Walang mount. Tingnan sa itaas. Nasa container ang data.

Sariling paksa ang buong trade-off, at saklaw ito ng bind mounts kumpara sa named volumes. Para sa database, ito ang maikling bersyon: gumamit ng named volume maliban kung may partikular kang dahilan para malaman ang host path. Kung gagamit ka ng bind mount, ilagay ito sa stable na lokasyon gaya ng /srv/appname/pg sa halip na sa loob ng project directory na maaaring maabot ng git clean.

Mag-ingat sa network storage. Huwag maglagay ng database data directory sa NFS (network file system) o sa iba pang network mount na hindi mo pa nasusuri ang locking at fsync behaviour. Tinutukoy ng PostgreSQL ang isang mahigpit na requirement para sa NFS: dapat gumagamit ang mount ng hard option. Mariin din nitong inirerekomenda ang sync export option sa NFS server, dahil kung wala ito, hindi garantisadong makararating sa disk ng server ang isang fsync mula sa client. Ipinapalagay ng mga database na ang matagumpay na fsync ay nangangahulugang nasa stable storage na ang mga byte. Kapag mali ang palagay na ito, magkakaroon ka ng corruption na lalabas makalipas ang ilang linggo.

I-pin ang volume name bago mawala ang volume

Gumagawa ang Compose ng pangalan para sa volume na <project>_<volume>, at ang project name ay nagde-default sa pangalan ng directory. Kaya nakadepende ang identity ng volume sa pangalan ng directory, na madalas napapalitan nang hindi napapansin.

Ilipat ang /srv/app sa /srv/app-old, o palitan ang pangalan ng pgdata key sa compose file, at gagawa ang susunod na docker compose up -d ng bagong volume na walang laman. Ii-initialize ng Postgres ang bagong cluster dito. Healthy ang container, nagsisimula ang application, at nawawala ang lahat ng table. Nasa disk pa rin ang dating volume gamit ang dating pangalan. Ito ang mabuting balita.

docker volume ls
docker volume inspect app_pgdata

I-pin ang mga pangalan para hindi ito mangyari. Itakda nang tahasan ang project name at volume name:

name: myapp

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

volumes:
  pgdata:
    name: myapp_pgdata

Kung may stray volume nang naglalaman ng iyong data, i-copy ito habang naka-stop ang 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

Kung magko-copy ka habang tumatakbo ang database, magkakaroon ka ng hindi kumpletong kopya ng mga file na isinusulat pa. I-stop muna ito.

Sino ang may-ari ng data directory

Ang official Postgres, MySQL, at MongoDB images ay nagpapatakbo ng server bilang unprivileged numeric user id: 999 sa default tags nila, at 70 sa Postgres -alpine tags. Kapag nagsimula ang container bilang root, binabago ng entrypoint ang ownership ng data directory para mapunta sa user na iyon, saka ibinababa ang privileges. Kaya karaniwang gumagana agad sa unang try ang isang walang laman na bind mount.

Nagkakaproblema ito kapag itinakda mo ang user: sa compose file, dahil wala nang natitirang privilege ang entrypoint para ayusin ang anuman. Direktang sinasabi ito ng Postgres:

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

Magbibigay ng ibang mensahe ang data directory na umiiral pero mali ang mode nito. Mahalagang makilala ang mensaheng ito dahil chmod ang tamang fix, hindi chown:

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

Inaayos din ng MongoDB entrypoint ang ownership sa parehong paraan. Kaya ang lock file error na ito ay nangangahulugang hindi nito nagawa ang pag-aayos: karaniwang nakatakda ang user:, o hindi pinapayagan ng mount ang chown mula sa root:

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.

Ang fix ay i-chown ang host directory gamit ang numeric id, hindi ang pangalan:

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

Ang ls -ldn ay nagpi-print ng mga numero sa halip na mga pangalan, at dapat nitong ipakita ang 999 999. Para sa Postgres -alpine image, gamitin naman ang 70:70 at asahang lalabas ang 70 70. Magkaiba at walang kaugnayan ang account na tinatawag na postgres sa host mo at ang account na tinatawag na postgres sa loob ng image: mga numero ang ikinukumpara ng kernel, at magkahiwalay na hinahanap ang mga pangalan sa bawat panig. Ipinaliliwanag nang maayos ng kung paano nagmamapa ang PUID at PGID ng mga host user sa isang container ang mapping na iyon. Sa rootless Docker o user namespace remapping, nag-iiba ulit ang mga numero, kaya basahin ang mga id mula sa tumatakbong container sa halip na ipagpalagay na 999.

Inaalis ng named volumes ang buong problemang ito sa unang run, dahil gumagawa ang Docker ng walang laman na directory at awtomatikong inaangkin ito ng entrypoint.

Mga upgrade: package upgrade laban sa pagbabago ng image tag

Sa host, ang apt upgrade ay naglilipat sa iyo sa susunod na minor version. Hindi awtomatikong mag-u-upgrade ang distribution mo sa susunod na major version ng database. Kapag pinili mong mag-upgrade, maaaring ma-install nang sabay ang dalawang set ng binary, na siyang kailangan ng pg_upgrade.

Sa container, ang tag ang nagsisilbing version, kaya ang upgrade ay pag-edit ng isang linya. Dahil dito, simple ang minor upgrade, pero nangangailangan ng procedure ang major upgrade.

Palitan ang postgres:16 ng postgres:17, patakbuhin ang docker compose up -d, at agad na mag-e-exit ang 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.

Walang nasisira. Tumanggi ang mga bagong binary na basahin ang lumang on-disk catalog layout, na nagbabago sa pagitan ng mga major version. Ibalik ang tag sa postgres:16 at muli itong magsisimula. Ang rollback na ito ang tunay na advantage ng container sa pag-upgrade.

Ang supported na proseso ay dump at restore. Mas gusto ng PostgreSQL na gawin ng mas bagong client ang dump, kaya patakbuhin ito mula sa bagong image laban sa lumang server na patuloy na tumatakbo sa compose network:

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

Dapat ay hindi bababa sa ilang dosenang kilobyte ang file at nagtatapos sa linyang PostgreSQL database cluster dump complete. Ang file na ilang daang byte lamang ay nangangahulugang nabigo ang dump, at buburahin mo na ang isang volume nang walang pakinabang. Pagkatapos lamang ng check na iyon:

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

Magplano para sa isa pang pagbabago sa postgres:18. Simula sa 18, inilalagay ng official image ang data nito sa isang versioned directory sa ilalim ng /var/lib/postgresql (para sa 18, /var/lib/postgresql/18/docker) at idinedeklara ang volume nito sa /var/lib/postgresql. Kapag naka-mount pa rin ang volume sa /var/lib/postgresql/data, mag-e-exit ang container na may error na nagsisimula sa Error: in 18+, these Docker images are configured to store database data. Kapag lumipat ka sa 18 o mas bago, palitan ang mount ng pgdata:/var/lib/postgresql. Ang mga path na /var/lib/postgresql/data sa post na ito ay para sa 17 at mas naunang version.

Magkakaiba ang ibang engine:

  • Ina-upgrade ng MySQL 8 ang sarili nitong data dictionary sa startup, kaya karaniwang restart lang ang minor tag bump. Basahin ang release notes bago lumipat sa ibang release series, at gumawa muna ng dump sa alinmang sitwasyon.
  • Inaasahan ng MariaDB na patakbuhin ang mariadb-upgrade matapos magsimula ang server sa bagong version.
  • Kailangang i-upgrade ang MongoDB nang tig-isang major version, at pagkatapos ng bawat hakbang ay itakda ang feature compatibility version bago magpatuloy. Kapag may nilaktawang version, tatanggi ang mongod na magsimula at magla-log ng linyang UPGRADE PROBLEM na tumutukoy sa featureCompatibilityVersion. Simula sa MongoDB 7.0, kailangan ng command ng explicit confirmation flag: db.adminCommand({ setFeatureCompatibilityVersion: "8.0", confirm: true }).
  • Masayang nilo-load ng Redis ang mas lumang snapshot file, pero hindi ang mas bagong file. Kaya ang upgrade ay restart, at maaaring mabigo ang downgrade na i-load ang data.

Ang pangkalahatang tuntunin: pinapadali ng container ang downgrade, pero hindi nito ginagawang mas madali ang upgrade.

Bakit lumalabas ang database container na may exit code 137?

Pinatay ito ng kernel's out of memory (OOM) killer. Ang 137 ay 128 dagdag sa signal 9.

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

Ipinapakita ng docker compose ps --all ang Exited (137). Kung wala ang --all, tumitingin ang Compose sa mga tumatakbong container lamang, kaya hindi lumalabas sa output ang tumigil na database. Ang inspect line ay "OOMKilled": true, at may katugmang entry sa kernel log:

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

Sinasabi lamang ng OOMKilled na tinapos ng OOM killer ang isang process sa loob ng container. Ang prefix na Memory cgroup out of memory ang nagsasabing sariling limit ng container ang nalampasan. Sa malawakang kakulangan ng memory sa host, Out of memory: Killed process ang naka-log, at ang dapat ayusin ay ang host, hindi ang container.

Ganito gumagana ang mekanismo, at madalas itong ikinagugulat ng mga user. Sa loob ng container, ipinapakita pa rin ng free at /proc/meminfo ang kabuuang memory ng host. Hindi binabago ng cgroup limit ang numerong iyon. Hindi ginagamit ng PostgreSQL ang numerong iyon sa pag-size ng mga setting: ang default ng shared_buffers ay 128MB, at anumang mas malaking value ay itinakda mo o ng isang tuning guide. Ang innodb_buffer_pool_size ng MySQL ay default din na 128M. Nagsisimula ang problema kapag ibinatay ang mga setting sa memory na iniulat ng machine. Iminumungkahi ng sariling guidance ng PostgreSQL ang 25% ng system memory bilang panimulang shared_buffers. Kaya sa host na may 16 GB at limit na 2 GB, nagbibigay ang rule na iyon ng 4 GB, at papatayin ng cgroup ang database bago pa magkaroon ng pressure ang host. May ilang engine na ngayon na gumagamit ng limit para sa ilang default: ginagawa ito ng MySQL 9.3 at mga susunod na version, at ginagamit ito ng MongoDB para sa WiredTiger cache kapag natutukoy nito ang limit. Gayunman, hindi nito bina-base rito ang lahat ng setting, at sinasabi ng sariling documentation ng MongoDB na maaaring mabigo ang detection. Kaya hindi sapat ang memory limit lamang. Kailangan mo ring sabihin sa database kung gaano karaming memory ang mayroon ito:

  • PostgreSQL: itakda ang shared_buffers, at bigyang-pansin ang work_mem. Nalalapat ang work_mem sa bawat sort o hash operation, at maaaring sabay-sabay na magpatakbo ng ilan ang bawat connection. Kaya ang malaking value na minultiply sa limampung connection ang karaniwang dahilan kung bakit namamatay ang container kapag may load, sa halip na sa startup.
  • MySQL at MariaDB: itakda ang innodb_buffer_pool_size, na may default na 128M. Sa MySQL na mas luma sa 9.3, iwanang naka-off ang innodb_dedicated_server sa isang container, dahil ibinabase nito ang buffer pool sa memory ng machine, na ang ibig sabihin dito ay memory ng host. Simula 9.3, binabasa ng MySQL ang limits ng container at ibinabase rito ng innodb_dedicated_server ang size, ngunit mas predictable pa rin ang explicit na buffer pool size.
  • MongoDB: itakda nang tahasan ang WiredTiger cache size. Ginagamit ng MongoDB ang limit ng container kapag natutukoy nito ito (iniuulat ito ng hostInfo bilang memLimitMB), ngunit nagbababala ang sariling documentation nito na maaaring hindi ito matukoy sa ilang sitwasyon at ipinapayo nitong itakda ang --wiredTigerCacheSizeGB o --wiredTigerCacheSizePct na mas mababa sa memory ng container.
  • Redis: default na unlimited ang maxmemory, kaya patuloy na lumalaki ang Redis hanggang pigilan ito ng cgroup. Itakda ang maxmemory na may sapat na luwag sa ibaba ng limit ng container at pumili ng maxmemory-policy.

Iniuulat din ng Postgres ang event mula sa sariling panig nito. Ito ang pares ng mga linyang makikita mo sa 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

Ang pagkakapatáy sa isang backend ay nag-uutos sa lahat ng iba pang backend na mag-restart, dahil maaaring hindi na consistent ang shared memory. Nagdudulot ito ng connection storm sa application mo, hindi ito tahimik na event. Tinalakay sa pagtatakda ng memory limits sa Docker Compose ang syntax at ang pagkakaiba ng mem_limit at ng form na deploy.resources.

Hindi nawawala ang problemang ito sa host. Lumilipat lamang ito. Kung walang cgroup, nakikipagkumpitensya ang database sa lahat ng iba pang process sa machine, at pumipili ng victim ang host OOM killer batay sa score; maaaring sshd ang mapili. Mas madaling patakbuhin ang system kapag predictable na pinapatay ng limit ang database kaysa kapag pinapatay ng host OOM ang isang process at nawawalan ka ng access sa server.

Mga Backup: dump sa loob, backup sa labas

Huwag mag-backup ng tumatakbong database sa pamamagitan ng pagkopya ng data directory nito. Ang file-level copy na ginawa habang nagsusulat ang server ay hindi kumpletong kopya, at malalaman mo lang ito kapag oras na para mag-restore.

Dalawa ang maaasahang paraan: gumamit ng sariling tool ng database para gumawa ng dump habang tumatakbo ito, pagkatapos ay i-backup ang dump; o ihinto ang container at kopyahin ang volume habang naka-stop ito.

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

Mahalaga ang -T. Kung wala ito, maaaring mag-attach ang docker compose exec ng terminal sa command, at nagdaragdag ang terminal layer ng carriage returns sa output stream. Magkakaroon ng kakaibang error kapag nag-restore ng text dump, at masisira naman nang tuluyan ang binary dump. Tahimik itong pumapalya sa oras ng backup at malakas na lumilitaw makalipas ang isang buwan.

Nagbibigay ang --single-transaction sa mysqldump ng consistent snapshot ng mga InnoDB table nang hindi nilo-lock ang buong server.

Isang file ang sinusulat ng bawat command. Hindi pa ito backup system: walang retention, walang off-box copy, at walang verification. Ibigay ang dump directory sa tool na gumagawa ng tatlong ito, gaya ng restic backups mula sa isang VPS. I-backup ang /srv/backups, hindi ang /var/lib/docker/volumes.

Pagkatapos, patakbuhin ang restore, dahil hindi maituturing na backup ang backup na hindi mo pa na-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'

Dapat ilista ng \dt ang mga table ng application mo. Ang walang laman na resulta o ang Did not find any relations. ay nangangahulugang hindi ang inaakala mo ang dump. I-drop ang restore_test kapag tapos ka na.

Ang command na nagde-delete ng lahat

docker compose down -v.

Ang plain na down ay nag-aalis ng mga container at ng network. Inaalis din ng -v ang bawat named volume na dineklara sa compose file na iyon, pati ang bawat anonymous volume na nakakabit sa mga container na iyon. Walang prompt at walang undo. Ito ang pinakakaraniwang paraan kung paano nasisira ang isang self-hosted database. Karaniwan itong nangyayari habang nagta-troubleshoot ng ibang problema, dahil may forum answer na nagsabing patakbuhin ito.

Apat na bagay ang nakakabawas sa blast radius:

  • I-declare ang database volume bilang external: true. Hindi aalisin ng Compose ang volume na hindi nito pagmamay-ari, kaya hindi ito maaabot ng -v. Gawin ito nang isang beses gamit ang docker volume create myapp_pgdata.
  • Gamitin ang docker compose stop at docker compose start para sa mga regular na restart. Ipinapaliwanag ng down kumpara sa stop sa Compose kung ano ang inaalis ng bawat isa.
  • Panatilihin ang mga dump sa isang host path na nasa labas ng lahat ng volume na mina-manage ng Compose.
  • Huwag kailanman i-paste ang -v mula sa isang troubleshooting answer sa stack na may data na mahalaga sa iyo.

Huwag i-publish ang database port

Inilalagay ng linyang ito ang database sa public internet:

    ports:
      - "5432:5432"

Naka-bind ito sa lahat ng interface. Nire-rewrite ng Docker ang destination ng packet bago pa ito makita ng input rules ng firewall, at nasa input chain ang rules ng ufw. Kaya walang epekto ang ufw deny 5432. Ipinapakita sa kung bakit nababypass ng Docker ang ufw sa mga published port ang pagdaan ng packet sa chain.

Nakaka-access ang application sa parehong compose project sa database gamit ang service name sa compose network, kaya hindi nito kailangan ng published port. Tanggalin ang block. Kung kailangan ng client sa host, i-bind lamang ito sa loopback:

    ports:
      - "127.0.0.1:5432:5432"

Suriin kung ano talaga ang nakikinig:

sudo ss -ltnp | grep 5432

Ang 127.0.0.1:5432 ang gusto mo. Ibig sabihin ng 0.0.0.0:5432, maaaring subukan ng kahit sino ang iyong password.

Ano ang dapat patakbuhin at saan

Isang application sa isang VPS. Gumamit ng container. Magtakda ng named volume na may fixed na pangalan, huwag mag-publish ng port, magtakda ng memory limit na tugma sa database settings, at gumawa ng nightly dump sa host path na kinokolekta ng restic. Magsimula sa malinis na Docker install sa isang VPS at ilagay ang buong stack sa isang compose file na kino-commit mo. Malinaw ang pakinabang: nagiging linya sa git na maaaring i-review ang database version.

Isang host na nagpapatakbo ng ilang serbisyo. Gumamit ng mga container, na may tig-isang database bawat application, hindi isang shared server para sa lahat. Kapag shared server ang gamit, nakatali ang bawat application sa iisang upgrade schedule, at ang isang runaway query ay maaaring magdulot ng outage sa lahat. Bigyan ang bawat container ng sarili nitong memory limit upang ang maling query ay manatiling limitado sa application na pinagmulan nito. Bahagyang mas malaki ang disk cost ng ilang maliliit na Postgres instance, pero mas kaunti ang coordination na kailangan.

Ang database ang pangunahing produkto. Patakbuhin ito sa host gamit ang package repository ng vendor, o gumamit ng managed service. Kailangang sabay na naka-install ang dalawang major version ng binaries para sa pg_upgrade. Ibinibigay ito ng mga package, samantalang hindi ito magagawa ng isang single-version image. Mas madali ang replication at point-in-time recovery gamit ang WAL (write-ahead log) archiving kapag ang database ang nagmamay-ari sa machine at mga disk nito. Piliin ang simple at subok na paraan para sa system na magpapadala sa iyo ng page sa 03:00.

Maliit ang application. Isaalang-alang ang hindi paggamit ng server database. Ang isang single-writer web application sa isang VPS ay madalas na mas angkop sa SQLite sa production sa isang VPS, kung saan isang file lamang ang backup at library version ang upgrade path.

FAQ

Ligtas bang magpatakbo ng production database sa Docker?

Oo, para sa application stack na nasa iisang server. Ang container ay isang Linux process na napapalibutan ng namespaces at cgroups. Kapag may naka-mount na volume, sa parehong host filesystem nagsusulat ang database na gagamitin nito kung ini-install mo ito mula sa package. Operational ang mga panganib, hindi tungkol sa bilis: volume na hindi naka-pin ang pangalan, bind mount na pagmamay-ari ng maling user id, restore na hindi mo pa nasusubukan, at docker compose down -v. Kapag naayos ang apat na ito, maayos ang container. Lumipat sa host install kapag ang database ang pangunahing workload at kailangan mo ng pg_upgrade, replication, o point in time recovery.

Dapat ba akong gumamit ng bind mount o named volume para sa data ng database?

Gumamit ng named volume maliban kung may partikular kang dahilan para malaman ang host path. Ginagawa ng Docker ang directory, at itinatakda ng image entrypoint ang ownership sa unang pagsisimula. Kaya hindi lumilitaw ang permission problem. I-pin ang volume gamit ang tahasang name: o markahan ito bilang external: true. Kung hindi, kapag pinalitan ang pangalan ng project directory, tahimik na gagawa ang Docker ng bagong walang-lamang volume at empty database. Maayos ang bind mount kung gagamitin mo ang chown sa host directory upang itakda ito sa numeric user id na ginagamit ng image. Ang id na ito ay 999 para sa default tags ng official Postgres, MySQL, at MongoDB images, at 70 para sa Postgres -alpine tags. I-verify ito gamit ang ls -ldn, dahil ipinapakita ng ls -l ang pangalan ng host para sa numerong iyon, at walang saysay ang pangalang iyon sa loob ng container.

Ano ang binubura ng docker compose down -v?

Tinatanggal nito ang mga container at ang network, gaya ng plain down. Tinatanggal din ng -v ang bawat named volume na idineklara sa compose file na iyon, pati ang bawat anonymous volume na naka-attach sa mga container. Kasama rito ang database. Walang confirmation prompt at walang recovery. Hindi tinatanggal ang mga volume na minarkahang external: true. Ito ang pangunahing dahilan kung bakit dapat markahan ang database volume bilang external. Para sa karaniwang restart, gamitin ang docker compose stop at docker compose start.

Paano ko ia-upgrade ang PostgreSQL sa bagong major version sa Docker?

Gumamit ng dump at restore. Kapag pinalitan ang postgres:16 ng postgres:17 at ni-restart ito, makakakuha ka ng FATAL: database files are incompatible with server na may DETAIL line na naglilista sa dalawang version. Hindi mababasa ng bagong binaries ang lumang catalog layout. Walang nasisira: ibalik ang lumang tag at magsisimula ulit ito. Gumawa ng pg_dumpall gamit ang client ng bagong version laban sa kasalukuyang tumatakbong lumang container. Tiyaking nagtatapos ang file sa PostgreSQL database cluster dump complete. Pagkatapos, patakbuhin ang bagong tag sa empty volume at i-load ang dump. Mula sa postgres:18, i-mount ang volume na iyon sa /var/lib/postgresql sa halip na /var/lib/postgresql/data. Para sa minor upgrades sa loob ng iisang major version, kailangan lamang ng pull at restart.

Bakit nag-e-exit ang database container ko na may code 137?

Ang 137 ay 128 dagdag sa signal 9, kaya may puwersahang nag-terminate sa process. Patakbuhin ang docker inspect <container> | grep -i oomkilled. Ang value na true ay nangangahulugang tinapos ng OOM killer ang isang process sa container, karaniwan dahil naabot ng container ang sarili nitong cgroup memory limit. Karaniwang sanhi nito ang memory settings na ibinatay sa host sa halip na sa container. Ipinapakita pa rin ng mga tool sa loob ng container ang kabuuang memory ng host, kaya ang buffer na itinakda para sa 16 GB ay maaaring mapunta sa loob ng 2 GB. Itakda ang shared_buffers at work_mem, o innodb_buffer_pool_size, upang umangkop sa limit na ibinigay mo sa container. Suriin ang journalctl -k para sa katugmang Memory cgroup out of memory line. Kinukumpirma nito kung aling process ang pinili ng kernel at kung container limit ang dahilan, hindi isang host-wide Out of memory kill.

Nakatulong ba ang artikulong ito?