FreeBSD మరియు Linuxలో ZFS: RAM వినియోగం అంచనా

ZFS మీకు అందించేది, దానికి అవసరమయ్యేది

FreeBSD మరియు Linuxలో ZFS ఇప్పుడు OpenZFS అనే ఒకే codebase పై నడుస్తుంది. అందువల్ల రెండు systemsలోనూ features ఒకే విధంగా ఉంటాయి. ZFS నడుస్తున్న serverలో checksummed data, data మారే వరకు అదనపు ఖర్చు లేని snapshots, zfs send తో replication, మరియు ఒక property మార్చడం ద్వారా అందుబాటులోకి వచ్చే compression ఉంటాయి. దీనికి అవసరమయ్యేది memory. ARC (adaptive replacement cache) defaultగా RAMలో పెద్ద భాగాన్ని ఉపయోగిస్తుంది. 2 GB లేదా 4 GB VPS (virtual private server)లో ఆ memory మీ applicationకు ఖచ్చితంగా అవసరమైనదే.

ఈ guide ZFSను నలభై drive bays ఉన్న storage box ఆధారంగా కాకుండా, ఒకటి లేదా రెండు virtual disks ఉన్న rented VPS ఆధారంగా అంచనా వేస్తుంది. ఆ పరిస్థితిలోనూ ఉపయోగకరంగా ఉండే features మీ సమయానికి విలువైనవి. ఆ పరిస్థితిలో ఉపయోగకరంగా ఉండని అంశాలను pool నిర్మించే ముందు తెలుసుకోవడం మంచిది.

FreeBSD మరియు Linuxలో OpenZFS: ఒకే codebase, రెండు packaging విధానాలు

FreeBSD 2008లోని FreeBSD 7.0 నుంచి ZFSను base systemలో చేర్చింది. మొదట ఇది experimental featureగా ఉండేది. December 2020లోని OpenZFS 2.0 నుంచి FreeBSD మరియు Linux ఒకే source tree నుంచి build అవుతున్నాయి. అందువల్ల zfs మరియు zpool రెండింటిలోనూ ఒకే విధంగా పనిచేస్తాయి. ఒకదానిలో సృష్టించిన poolను మరొకదానిలో import చేయవచ్చు.

Linuxలో ZFS ఒక packageగా ఉండటానికి, FreeBSDలో base systemలో భాగంగా ఉండటానికి కారణం licensing. OpenZFS, CDDL (common development and distribution license) కింద అందుబాటులో ఉంది. Linux kernel, GPL (general public license) version 2 కింద ఉంది. Kernel project ఈ రెండు licensesను పరస్పరం అనుకూలం కానివిగా పరిగణిస్తుంది. అందువల్ల ZFS code mainline Linuxలో merge కాలేదు. ప్రతి distribution దాన్ని ఎలా ship చేయాలో స్వయంగా నిర్ణయిస్తుంది. FreeBSDలో ఈ conflict లేదు. అందువల్ల ZFS అక్కడ సహజంగానే అందుబాటులో ఉంటుంది. ఆచరణలో మొత్తం విషయం ఇదే: packagingలో ఒక తేడా మాత్రమే ఉంది. దీనిపై మీరు ఏదో ఒక వైపు ఎంచుకోవాల్సిన అవసరం లేదు.

SSD Nodes, FreeBSD imagesను అందించదు. కాబట్టి ఇక్కడ అద్దెకు తీసుకున్న serverలో ఈ guideలోని Linux భాగమే వర్తిస్తుంది. మీరు FreeBSDని వేరే చోట నడిపితే, FreeBSD serverలో build చేయాల్సిన module ఉండదు. Kernel upgrade తర్వాత కూడా ప్రత్యేకంగా నిర్వహించాల్సిన అవసరం ఉండదు.

ZFSను ఇన్‌స్టాల్ చేసి pool సృష్టించడం

Ubuntuలో module kernel packagesలోనే ఉంటుంది. అందువల్ల commandsను మాత్రమే ఇన్‌స్టాల్ చేయాలి.

sudo apt update
sudo apt install -y zfsutils-linux
zfs version

zfs version రెండు linesను print చేస్తుంది: userland version మరియు kernel module version. ఒక line మాత్రమే కనిపిస్తే module load కాలేదు. Package universe componentలో ఉంటుంది. Ubuntu server images దీనిని defaultగా enable చేస్తాయి. apt దాన్ని కనుగొనలేకపోతే ముందుగా sudo add-apt-repository universe నడపండి.

Debianలో packages contrib componentలో ఉంటాయి. DKMS (dynamic kernel module support) ద్వారా module మీ machineలో build అవుతుంది. /etc/apt/sources.list.d/debian.sources లోని Components: lineకు contrib ను జోడించి, sudo apt update నడపండి. తరువాత:

sudo apt install -y linux-headers-$(dpkg --print-architecture) zfs-dkms zfsutils-linux

ఈ install moduleను compile చేసి Building initial module for 6.12.0-... ను print చేస్తుంది. దీనికి కొన్ని నిమిషాలు పడుతుంది. దీని అర్థాన్ని గుర్తుంచుకోండి: ప్రతి kernel upgrade సమయంలో module మళ్లీ build అవుతుంది. Build విఫలమైతే, సమస్యను పరిష్కరించే వరకు మీ pool import కాదు.

FreeBSDలో ఏదీ install చేయబడదు. Serviceను enable చేసి start చేయండి.

sysrc zfs_enable=YES
service zfs start

ఇప్పుడు poolను సృష్టించండి. ముందుగా స్థిరమైన device pathsను పరిశీలించండి. ఎందుకంటే /dev/vdb detection order ఆధారంగా కేటాయించబడుతుంది. మరో volumeను జత చేసినప్పుడు ఇది మారవచ్చు.

ls -l /dev/disk/by-id/
sudo zpool create -o ashift=12 tank /dev/disk/by-id/virtio-abc123def456
zpool status tank

zpool status మీ deviceను tank కింద చూపిస్తూ state: ONLINE ను print చేయాలి. ashift=12 poolలోని అతి చిన్న block పరిమాణాన్ని 4 KiBగా నిర్ధారిస్తుంది. ఇది ప్రస్తుత SSDలకు సరిపోతుంది. Pool సృష్టించిన తర్వాత దీన్ని మార్చలేరు.

చాలా rented images ext4 root నుంచి boot అవుతాయి. అందువల్ల ఇక్కడ ZFS root filesystem కాకుండా రెండో volumeలోని data poolగా ఉంటుంది. Device మీరు భావిస్తున్నదేనా అని దానిపై నిర్మాణం ప్రారంభించే ముందు తనిఖీ చేయండి. మీరు కొనుగోలు చేసిన NVMe diskను నిర్ధారించడానికి ఒక నిమిషం పడుతుంది. Rebuildకు ఒక మధ్యాహ్నం పడుతుంది.

పూల్‌లో redundancy ఉన్నప్పుడు మాత్రమే checksums మరమ్మతు చేయగలవు

ZFS వ్రాసే ప్రతి block కు checksum ఉంటుంది. ప్రతి read సమయంలో ఆ checksum ధృవీకరించబడుతుంది. లోపాన్ని గుర్తించడం ఎల్లప్పుడూ సాధ్యమే. మరమ్మతుకు రెండో copy అవసరం.

single-disk pool లో ZFS వాస్తవాన్ని తెలియజేసి అక్కడితో ఆగిపోతుంది. zpool status -v దాన్ని ఇలా చూపిస్తుంది:

status: One or more devices has experienced an error resulting in data
        corruption.
action: Restore the file in question if possible.  Otherwise restore the
        entire pool from backup.
errors: Permanent errors have been detected in the following files:

        /tank/data/archive.tar

లోపం ఉన్న file పేరు చూపబడుతుంది. ext4 అయితే ఆ bytes ను ఎలాంటి వ్యాఖ్య లేకుండా తిరిగి ఇచ్చేది. కాబట్టి ఇది కూడా ఉపయోగకరమైన సమాచారం. అయితే pool లో మరమ్మతుకు ఉపయోగించగల రెండో copy లేకపోవడంతో ZFS దాన్ని సరిచేయలేడు.

mirror ఉన్నప్పుడు అదే read మంచి వైపు నుంచి అందించబడుతుంది. లోపం ఉన్న block తిరిగి వ్రాయబడుతుంది. ఆ event zpool status లోని CKSUM column లో కనిపిస్తుంది. ఇదే self-healing. దీనికి రెండు devices అవసరం.

sudo zpool create -o ashift=12 tank mirror /dev/disk/by-id/DISK1 /dev/disk/by-id/DISK2

VPS లో host storage సాధారణంగా ఇప్పటికే redundant గా ఉంటుంది. చాలా సందర్భాల్లో hypervisor కింద RAID 10 ఉపయోగిస్తారు. ఇది drive విఫలమైనప్పుడు రక్షణ ఇస్తుంది. అయితే ఏ copy సరైనదో array కు తెలియదు. అందువల్ల block తప్పుగా తిరిగి వచ్చినప్పుడు దాన్ని గుర్తించలేడు. ZFS తాను వ్రాసిన checksum తో data ను పోల్చడం ద్వారా దీన్ని గుర్తించగలదు.

మీ వద్ద ఒక virtual disk మాత్రమే ఉండి, కొంత repair సామర్థ్యం కావాలంటే, sudo zfs set copies=2 tank/important ఆ dataset లోని ప్రతి block కు అదే disk పై రెండు copies నిల్వ చేస్తుంది. దీనివల్ల ఆ dataset ఉపయోగించే space రెండింతలు అవుతుంది. ఇది bad block వచ్చినా తట్టుకుంటుంది. అయితే మొత్తం volume మాయమైతే దీనివల్ల ఎలాంటి ప్రయోజనం ఉండదు.

scrub pool లోని మొత్తం data ను read చేసి ధృవీకరిస్తుంది.

sudo zpool scrub tank
zpool status tank

ఆరోగ్యంగా ఉన్న pool చివరలో scan: scrub repaired 0B in 00:04:11 with 0 errors వంటి line కనిపిస్తుంది. దీన్ని schedule చేయండి. చిన్న pool కు నెలకు ఒకసారి సరిపోతుంది.

systemctl list-unit-files 'zfs-scrub*'
sudo systemctl enable --now zfs-scrub-monthly@tank.timer

డేటాసెట్లు విధానానికి ప్రాథమిక యూనిట్లు

డేటాసెట్ అనేది pool లోని ఒక filesystem. దాన్ని సృష్టించడానికి పెద్ద ఖర్చు ఉండదు. అందువల్ల ప్రతి job కోసం ఒక డేటాసెట్‌ను సృష్టించండి. Properties pool నుంచి దిగువకు inherit అవుతాయి. అంటే ఒక default ను ఒక్కసారి సెట్ చేసి, అవసరమైన చోట మాత్రమే override చేయవచ్చు. FreeBSDలో jails ను సాధారణంగా ఈ విధంగానే నడుపుతారు. ప్రతి jail కోసం ఒక డేటాసెట్‌ను ఉంచుతారు. దాంతో ఒక jail ను విడిగా snapshot చేసి, rollback చేయవచ్చు. ఇది jail ను Docker container నుంచి వేరు చేసేది ఏమిటో చూపించే అంశాల్లో ఒకటి.

sudo zfs create tank/data
sudo zfs create tank/pg
sudo zfs set compression=lz4 tank
sudo zfs set atime=off tank
sudo zfs set quota=20G tank/data
sudo zfs set recordsize=16K tank/pg
zfs get -r compression,compressratio,quota tank

Compression అనేది జాగ్రత్తతో enable చేయకుండా వదిలే property. కానీ అది సరైన విధానం కాదు. lz4 కు కొద్దిపాటి CPU మాత్రమే అవసరం. ఇది disk కు రాయాల్సిన bytes ను తగ్గిస్తుంది. అందువల్ల compressible data పై reads మరియు writes సాధారణంగా వేగంగా జరుగుతాయి. zstd ఎక్కువ CPU వినియోగించి మరింత బలమైన compression చేస్తుంది. అరుదుగా తిరిగి చదివే logs మరియు archives కు ఇది అనుకూలంగా ఉంటుంది. వాస్తవంగా ఎంత compression లభిస్తుందో zfs get compressratio tank తో తనిఖీ చేయండి. Ratio అనేది property సెట్ చేసిన తర్వాత రాసిన data ను మాత్రమే లెక్కిస్తుందని గుర్తుంచుకోండి.

recordsize అనేది dataset రాసే అతిపెద్ద block పరిమాణం. Default గా ఇది 128K. Database 128 KiB records లో 8 KiB pages రాస్తే, ఒక చిన్న write మొత్తం record ను read చేసి, దాన్ని మార్చి, తిరిగి write చేయాల్సి వస్తుంది. Data load చేయడానికి ముందు database dataset పై recordsize=16K సెట్ చేయండి. ఈ property కొత్తగా రాసే blocks కు మాత్రమే వర్తిస్తుంది.

quota ఒక dataset pool మొత్తాన్ని నింపకుండా నిరోధించే విధానం. ZFS pool 100% కు దగ్గరగా నిండితే పనితీరు తగ్గుతుంది మరియు cleanup చేయడం క్లిష్టమవుతుంది. అందువల్ల ముందుగానే headroom ఉంచండి.

డేటా మారే వరకు Snapshots కు ఖర్చు ఉండదు

ZFS ఎప్పుడూ ఉపయోగంలో ఉన్న block ను overwrite చేయదు. అది కొత్త block ను రాసి pointers ను update చేస్తుంది. దీనినే copy-on-write అంటారు. ఒక snapshot అంటే “ఈ dataset ప్రస్తుతం చూపిస్తున్న blocks ను అలాగే ఉంచాలి” అని నమోదు చేసే సూచన. అందువల్ల snapshot తీసుకోవడం తక్షణమే జరుగుతుంది, అదనపు స్థలం కూడా అవసరం ఉండదు.

sudo zfs snapshot tank/data@2026-08-11
zfs list -t snapshot -o name,used,refer -r tank/data

Snapshot కోసం USED column చూపించే స్థలం ఆ snapshot ఒక్కటే నిలుపుకున్న స్థలం. ఇది మొదట దాదాపు zero గా ఉంటుంది. మీరు data ను మార్చినప్పుడు లేదా తొలగించినప్పుడు ఇది పెరుగుతుంది, ఎందుకంటే పాత blocks ను ఇక విడుదల చేయలేరు.

ఫైల్‌ను తిరిగి పొందడానికి ప్రత్యేక restore దశ అవసరం లేదు.

ls /tank/data/.zfs/snapshot/
cp /tank/data/.zfs/snapshot/2026-08-11/notes.txt /tank/data/notes.txt

.zfs directory, మీరు sudo zfs set snapdir=visible tank/data ను run చేసే వరకు ls -a కు కూడా కనిపించదు. అవసరం ఏర్పడకముందే snapshot తీసుకోండి. లేకపోతే ఒక అనుకోని rm -rf మిమ్మల్ని ext4 recovery మార్గంలోకి పంపుతుంది. ఆ ప్రక్రియ disk ను unmount చేయడంతో ప్రారంభమై, అక్కడి నుంచి మరింత క్లిష్టమవుతుంది.

Rollback snapshot తీసిన తర్వాత రాసిన ప్రతిదాన్ని తొలగిస్తుంది.

sudo zfs rollback tank/data@2026-08-11

కొత్త snapshots ఉన్నప్పుడు ఇది తిరస్కరిస్తుంది. కొనసాగించడానికి -r ఆ కొత్త snapshots ను తొలగిస్తుంది. Enter నొక్కే ముందు dataset పేరు రెండుసార్లు తనిఖీ చేయండి.

Snapshot backup కాదు. ఇది అదే pool లో, అదే volume పై, అదే server లో ఉంటుంది. విఫలమైన volume లేదా ఒక zpool destroy snapshot లను data తో పాటు నాశనం చేస్తుంది. మీ స్వంత rm మరియు తప్పు upgrade నుంచి snapshots రక్షణ కల్పిస్తాయి. ఇవి అనేక వాస్తవ సంఘటనలను ఎదుర్కోవడానికి సహాయపడతాయి. అయితే pool కు జరిగే నష్టం నుంచి snapshots ఎలాంటి రక్షణ ఇవ్వవు. పూర్తి వివరణ ఇక్కడ ఉంది: VPS snapshot backup ఎందుకు కాదు.

పంపడం మరియు స్వీకరించడం: ఒకే commandలో replication

zfs send snapshot ను standard output పై byte streamగా మారుస్తుంది. zfs receive ఆ streamను మళ్లీ datasetగా మారుస్తుంది. మొదటి copy పూర్తి send అవుతుంది.

sudo zfs snapshot tank/data@daily-2026-08-11
sudo zfs send tank/data@daily-2026-08-11 | ssh backup.example.com "sudo zfs recv -F backup/data"

ఆ తర్వాత రెండు snapshots మధ్య మారిన డేటాను మాత్రమే పంపండి.

sudo zfs snapshot tank/data@daily-2026-08-12
sudo zfs send -i tank/data@daily-2026-08-11 tank/data@daily-2026-08-12 | ssh backup.example.com "sudo zfs recv backup/data"

మీరు పంపుతున్న snapshot receiving sideలో కూడా ఉండాలి. అది లేకపోతే receive cannot receive incremental stream: most recent snapshot of backup/data does not match incremental sourceతో ఆగిపోతుంది, ఎందుకంటే తేడాను వర్తింపజేయడానికి ZFS వద్ద base ఉండదు. రెండు వైపులా ఉన్న snapshot నుంచి పంపండి లేదా పూర్తి sendతో మళ్లీ ప్రారంభించండి.

Remote rootను ఉపయోగించకుండా targetపై హక్కులు ఇవ్వండి: sudo zfs allow -u backupuser create,mount,receive backup/data.

ఇది ఒక షరతుతో కూడిన నిజమైన off-site backup. దూరంలోని చివర తప్పనిసరిగా ZFS pool అయి ఉండాలి, ఎందుకంటే object storage streamను స్వీకరించలదు. మీ target S3-compatible storage లేదా సాధారణ Linux host అయితే, దానితో మాట్లాడగల toolను ఉపయోగించండి. VPS నుంచి restic backups ఆ విధానాన్ని వివరిస్తుంది.

ZFS ఎందుకు ఇంత RAM ఉపయోగిస్తుంది? ARC

ARC (adaptive replacement cache) అనేది ZFS యొక్క read cache. ఇది సాధారణ Linux page cache లో కాకుండా kernel memory లో ఉంటుంది. అందువల్ల free -h దాన్ని buff/cache కింద చూపించదు. అది ఉపయోగంలో ఉన్న memoryగా కనిపిస్తుంది. దాదాపు మొత్తం memory నిండినట్లు కనిపించే ZFS serverలో సాధారణంగా cache వేడిగా ఉండటం కారణం. “ZFS నా RAM మొత్తాన్ని తీసుకుంది” అనే చాలా నివేదికలకు ఇదే కారణం.

డిఫాల్ట్ పరిమితి ఉద్దేశపూర్వకంగా ఎక్కువగా ఉంటుంది. OpenZFS 2.3లో గరిష్ఠ ARC పరిమాణం RAM minus 1 GiB మరియు RAMలో 5/8 భాగం—ఇవాటిలో పెద్దదిగా ఉంటుంది. OpenZFS 2.2 మరియు అంతకుముందు Linuxలో RAMలో సగభాగాన్ని ఉపయోగించేవి. FreeBSDలో మాత్రం ఇప్పటికే కొత్త నియమం ఉపయోగించబడింది. మీ సిస్టమ్‌కు ఏ నియమం వర్తిస్తుందో చూడటానికి zfs version అమలు చేయండి.

[
  {
    "label": "2 GB VPS",
    "openzfs_2_2_linux_gib": 1,
    "openzfs_2_3_gib": 1.25
  },
  {
    "label": "4 GB VPS",
    "openzfs_2_2_linux_gib": 2,
    "openzfs_2_3_gib": 3
  },
  {
    "label": "8 GB VPS",
    "openzfs_2_2_linux_gib": 4,
    "openzfs_2_3_gib": 7
  },
  {
    "label": "16 GB VPS",
    "openzfs_2_2_linux_gib": 8,
    "openzfs_2_3_gib": 15
  }
]

ఈ గణాంకాలు సాధారణ instance పరిమాణాలకు వర్తింపజేసిన documented default rule ఆధారంగా రూపొందించబడ్డాయి. ఇవి నడుస్తున్న server నుంచి తీసుకున్న కొలతలు కావు. 4 GB instanceలో 2.3 నియమం 3 GiB ARCకు అనుమతిస్తుంది. అదే server 2.2లో 2 GiB వద్ద ఆగుతుంది. 2 GB instanceలో 2.3 నియమం కింద కూడా 1.25 GiB ARCకు అనుమతి ఉంటుంది. మిగిలిన memory మీ అప్లికేషన్‌కు అందుతుంది.

పట్టికను నమ్మకుండా, మీ స్వంత serverలోని నిజమైన గణాంకాలను చూడండి:

grep -E '^(size|c_max) ' /proc/spl/kstat/zfs/arcstats
arc_summary | head -n 20

మూడవ కాలమ్ bytesలో ఉంటుంది. c_max ప్రస్తుతం అమలులో ఉన్న గరిష్ఠ పరిమితి. size ARC ప్రస్తుతం కలిగి ఉన్న పరిమాణం.

ARC memoryని తిరిగి ఇస్తుంది. Kernel memory pressureను సూచించినప్పుడు ARC పరిమాణం తగ్గుతుంది. సమస్య timingలో ఉంటుంది. ఈ తగ్గింపు memory pressure వల్ల నడపబడుతుంది. అందువల్ల ఒకేసారి అనేక వందల MiB అడిగే processకు, ARC ఇంకా memoryని విడుదల చేస్తున్న సమయంలోనే OOM (out of memory) killer ఎదురుకావచ్చు. Database మరియు web server నడుస్తున్న 2 GB serverలో ఇది అరుదైన సంఘటన కాదు. Manual మార్పుల గురించి OpenZFS manual కూడా ఇదే చెబుతుంది: పరిమితిని తగ్గించడం వల్ల “shrinkingను ప్రేరేపించడానికి memory pressure లేకపోతే ARC తగ్గదు”.

చిన్న VPSలో ARC పరిమితిని ఎలా నిర్ణయించాలి

ముందుగా workload కు అవసరమైన memoryని నిర్ణయించండి. Database మరియు application కు అవసరమైన memoryని కలిపి లెక్కించండి. Operating system కోసం కొంత margin ఉంచండి. మిగిలిన memoryని ARCకు కేటాయించండి. Postgres మరియు ఒక web application నడుస్తున్న 4 GB instanceలో 512 MiB నుంచి 1 GiB వరకు ARCతో ప్రారంభించడం సరైనది.

దీన్ని liveగా bytesలో సెట్ చేయండి. ఇది 1 GiB.

echo 1073741824 | sudo tee /sys/module/zfs/parameters/zfs_arc_max

Reboot తర్వాత కూడా ఈ పరిమితి కొనసాగేందుకు దీన్ని సెట్ చేయండి.

echo 'options zfs zfs_arc_max=1073741824' | sudo tee /etc/modprobe.d/zfs.conf
sudo update-initramfs -u

Root filesystem mount కావడానికి ముందే module initramfs నుంచి load కావచ్చు. అందువల్ల మీరు ఇప్పుడే రాసిన fileను అది చదవకపోవచ్చు. ఈ కారణంగా initramfs దశ ముఖ్యమైనది. Reboot తర్వాత arcstatsలోని c_max lineతో విలువను నిర్ధారించండి.

Manualలోనే పేర్కొన్న రెండు జాగ్రత్తలు ఉన్నాయి. System నడుస్తున్నప్పుడు విలువను తిరిగి 0గా సెట్ చేయలేరు. కాబట్టి దీన్ని రద్దు చేయాలంటే fileను edit చేసి reboot చేయాలి. అలాగే సంఖ్యను తగ్గించిన వెంటనే పెద్ద ARC పరిమాణం తగ్గదు.

FreeBSDలో ఇదే పరిమితి vfs.zfs.arc కింద sysctlగా ఉంటుంది. ప్రస్తుత values మరియు మీ version ఉపయోగించే ఖచ్చితమైన nameను చూడటానికి sysctl vfs.zfs.arc అమలు చేయండి. తరువాత గరిష్ఠ విలువను /boot/loader.confలో రాయండి.

చిన్న server కోసం memoryకు సంబంధించిన మరో రెండు నియమాలు ఉన్నాయి. Deduplicationను offగానే ఉంచండి. Dedup table memoryలో ఉంటుంది. సాధారణంగా ప్రచురించే అంచనా ప్రకారం ప్రతి TB unique dataకు 1 నుంచి 3 GB RAM అవసరం. అలాగే zvolపై swap ఉంచవద్దు. Zvol అనేది pool నుంచి రూపొందించిన block device. Memoryని విడుదల చేయడానికి ప్రయత్నిస్తున్న అదే filesystem ద్వారా swapping జరిగితే machine deadlock కావచ్చు. Swapను plain partitionపై లేదా poolకు బయట ఉన్న swap fileలో ఉంచండి.

ext4 లేదా XFS తో పాటు restic మెరుగైన ఎంపిక అయ్యే సందర్భాలు

అదనపు memory మరియు రెండవ volume ఉన్న server‌లోనే ZFS తన ప్రయోజనాన్ని చూపుతుంది. అవి లేకపోతే సాధారణ filesystem తో పాటు సమర్థమైన backup tool ఉపయోగించడం ఉత్తమం. ఈ సందర్భాల్లో ext4 లేదా XFS ఎంచుకోండి:

• instance‌లో 2 GB లేదా 4 GB RAM మాత్రమే ఉంది, workload‌కు మొత్తం RAM అవసరం.
• ఒకే virtual disk ఉంది, రెండవ copy లేదు. అందువల్ల ZFS లోపాలను గుర్తించగలదు కానీ సరిచేయలేడు.
• మీ backup target object storage లేదా సాధారణ Linux host. అక్కడి వ్యవస్థ ఏదీ zfs send stream‌ను స్వీకరించదు.
• మీరు DKMS తో Debian నడుపుతున్నారు. module build కాకుండా మిగిలిపోయే kernel upgrade‌ను మీరు భరించలేరు.
• root filesystem‌లో ZFS అవసరం, కానీ provider images ext4 మాత్రమే అందిస్తున్నాయి.

ప్రత్యేక data volume, spare RAM (8 GB మరియు అంతకంటే ఎక్కువ ఉంటే సౌకర్యంగా ఉంటుంది), అలాగే snapshots మరియు zfs send ను కేవలం enable చేయడం కాకుండా ఉపయోగించే ప్రణాళిక ఉంటే ZFS కొనసాగించండి. మిగతా సందర్భాల్లో, server నియంత్రణలో లేని storage‌కు encrypted, deduplicated backups రాసే restic తో ext4 ఉపయోగించడం సరిపోతుంది. అదే స్థాయి రక్షణలో ఎక్కువ భాగాన్ని memory ఖర్చు లేకుండా పొందవచ్చు.

వైఫల్య పరిస్థితులు, మీరు చూసే సందేశాలతో

Reboot తర్వాత pool కనిపించదు. zpool status, no pools available ను ప్రింట్ చేస్తుంది. Import service /etc/zfs/zpool.cache ను చదువుతుంది. అందువల్ల ఆ ఫైల్‌లో లేని pool boot సమయంలో ఎప్పటికీ import కాదు. Import చేయగల poolలను sudo zpool import చూపిస్తుంది. sudo zpool import tank దాన్ని తిరిగి తీసుకువస్తుంది. sudo zpool set cachefile=/etc/zfs/zpool.cache tank ఆ మార్పును శాశ్వతంగా చేస్తుంది. మరో system నుంచి సరిగా export చేయని pool cannot import 'tank': pool may be in use from other system ను చూపిస్తుంది. వేరే host దాన్ని ఉపయోగించడం లేదని నిర్ధారించుకున్న తర్వాత sudo zpool import -f tank ఆ పరిస్థితిని override చేస్తుంది.

Kernel upgrade తర్వాత Debianలో modprobe: FATAL: Module zfs not found in directory /lib/modules/6.12.0-.... కొత్త kernel కోసం DKMS build కాలేదు. సాధారణంగా దీనికి సరిపోలే headers install చేయకపోవడమే కారణం. ఏ kernel కోసం ఏమి build అయిందో dkms status చూపిస్తుంది. తరువాత sudo apt install -y linux-headers-$(uname -r) ను అమలు చేసి, sudo dkms autoinstall దాన్ని rebuild చేస్తుంది. sudo zpool import tank poolను తిరిగి తీసుకువస్తుంది.

మీరు files delete చేసినా pool fullగానే ఉంది. Snapshot ఇంకా ఆ dataను reference చేస్తే, deleted data diskపై అలాగే ఉంటుంది. అందువల్ల du మరియు df వేర్వేరు ఫలితాలు చూపిస్తాయి. zfs list -o space -r tank usageను USEDDS మరియు USEDSNAPగా విభజిస్తుంది. USEDSNAP ఎక్కువగా ఉంటే కారణం అదే. sudo zfs destroy tank/data@2026-06-01 తో పాత snapshotsను destroy చేయండి. అప్పుడు space తిరిగి అందుబాటులోకి వస్తుంది.

zpool status లో CKSUM సంఖ్య పెరుగుతోంది. ZFS కంటే దిగువన ఉన్న ఏదో భాగం తప్పు dataను అందించింది. Mirrorలో ఇది warning మాత్రమే. Block repair చేయబడుతుంది. Single-disk poolలో file పోతుంది. zpool status -v ఆ file పేరును చూపిస్తుంది. ఈ poolలో నిల్వ చేయని backup నుంచి ఆ ఒక్క fileను restore చేయండి.

Server slowగా ఉంది మరియు swapping జరుగుతోంది. పైన వివరించిన విధంగా ARC పరిమాణాన్ని పరిమితం చేయండి. తరువాత arc_summary ను అమలు చేసి hit ratioను పరిశీలించండి. Working setను ఉంచడానికి ARC చాలా చిన్నగా ఉంటే ప్రతి read diskకు వెళ్తుంది. ఆ సమయంలో page cache ఉపయోగించే సాధారణ filesystem మీకు మెరుగైన పనితీరును అందిస్తుంది.

FAQ

ZFS కు VPS పై ఎంత RAM అవసరం?

ZFS 2 GB instance పై నడుస్తుంది. అయితే మీ అప్లికేషన్‌కు ఎంత RAM మిగులుతుందన్నదే అసలు ప్రశ్న. ఎలాంటి tuning చేయకపోతే, OpenZFS 2.3 ARC ను RAM నుంచి 1 GiB తీసివేసిన విలువ మరియు RAMలో 5/8 భాగంలో పెద్దదైన పరిమితి వరకు పెరగనిస్తుంది. అందువల్ల 4 GB సిస్టమ్ cache కోసం 3 GiB కేటాయించవచ్చు. మీ workload భరించగల విలువకు zfs_arc_max ను సెట్ చేసి, /proc/spl/kstat/zfs/arcstats నుంచి c_max line ను చదవడం ద్వారా దాన్ని నిర్ధారించండి.

ZFS snapshot backup అవుతుందా?

కాదు. Snapshot data ఉన్న అదే pool లో ఉంటుంది. అది చెడు rm మరియు విఫలమైన upgrade నుంచి నిలిచి ఉంటుంది. అయితే pool లేదా instance నశిస్తే snapshot కూడా నశిస్తుంది. zfs send ఉపయోగించి snapshot ను మరొక machine కు పంపండి, లేదా ఈ server నియంత్రించని storage కు data రాసే backup tool ను అమలు చేయండి.

FreeBSD మరియు Linux పై ZFS ఒకే విధంగా పనిచేస్తుందా?

December 2020లో వచ్చిన OpenZFS 2.0 నుంచి codebase ఒకటే. Commands, on-disk format కూడా ఒకటే. Pools ను రెండు systems మధ్య తరలించవచ్చు. తేడా packaging లో ఉంటుంది. FreeBSD base system లోనే ZFS ను ship చేస్తుంది. Linuxలో ప్రతి distribution తన విధానాన్ని నిర్ణయిస్తుంది. Ubuntu తన kernel packages లో module ను build చేస్తుంది. Debian మాత్రం DKMS ఉపయోగించి మీ machine పై దాన్ని build చేస్తుంది. అందువల్ల kernel upgrade తర్వాత rebuild విజయవంతం అయ్యే వరకు module అందుబాటులో లేకపోవచ్చు.

ఒక disk ఉన్న VPS పై ZFS corruption ను repair చేయగలదా?

ZFS corruption ను గుర్తించి file పేరును చూపగలదు. కానీ దాన్ని repair చేయలేదు, ఎందుకంటే repair కు block యొక్క రెండవ copy అవసరం. Dataset పై zfs set copies=2 అమలు చేస్తే double space ఉపయోగించి ఆ రెండవ copy లభిస్తుంది. ఇది bad block ను పరిష్కరిస్తుంది, కానీ కోల్పోయిన volume ను కాదు. నిజంగా స్వయంగా repair చేయగల పరిష్కారం రెండు volumes మధ్య mirror.

Compression server ను నెమ్మదిగా చేస్తుందా?

lz4 సాధారణంగా server ను వేగంగా చేస్తుంది. Compressed blocks వల్ల తక్కువ bytes write చేయాలి, తక్కువ bytes read చేయాలి. ప్రతి block పై CPU ఖర్చుతో పోలిస్తే ఆదా అయ్యే disk పని ఎక్కువగా ఉంటుంది. Pool root వద్ద compression=lz4 ను సెట్ చేయండి, తద్వారా ప్రతి dataset దాన్ని inherit చేసుకుంటుంది. తరువాత వాస్తవ data రాసిన తర్వాత zfs get compressratio tank ను పరిశీలించండి.