RAID 10 என்றால் என்ன? VPS சேமிப்பகத்தில் இதன் அவசியம்
RAID 1, 5, 6 மற்றும் 10 நிலைகளின் செயல்பாடுகள், rebuild செலவு மற்றும் VPS ஹோஸ்ட்கள் ஏன் NVMe-க்கு RAID 10-ஐ தேர்வு செய்கின்றன என்பதை அறியுங்கள். /proc/mdstat வாசிப்பது எப்படி?
RAID 10 என்றால் என்ன, VPS ஹோஸ்ட்கள் ஏன் இதைப் பயன்படுத்துகின்றன
RAID 10 என்பது மெய்நிகராக்கப்பட்ட NVMe (non-volatile memory express) டிரைவ்களில் பெரும்பாலான VPS ஹோஸ்ட்கள் பயன்படுத்தும் சேமிப்பக அமைப்பாகும். இதன் வழக்கமான இரண்டு-நகல் அமைப்பில், ஒவ்வொரு டிரைவும் ஒரு ஜோடி டிரைவில் பிரதிபலிக்கப்படுகிறது (mirror), பின்னர் அந்த பிரதிபலிக்கப்பட்ட ஜோடிகளுக்கு இடையே தரவு பிரிக்கப்படுகிறது (stripe). ஒரு டிரைவ் செயலிழந்தாலும் array தொடர்ந்து இயங்கும். இதில் பழுதுபார்ப்பு என்பது, செட்டில் உள்ள மற்ற அனைத்து டிரைவ்களையும் வாசித்து கணக்கிடுவதற்குப் பதிலாக, எஞ்சியிருக்கும் ஜோடி டிரைவிலிருந்து தரவை நேரடியாக நகலெடுப்பதாகும்.
RAID என்பது redundant array of independent disks என்பதன் சுருக்கமாகும். இதற்கு ஒரே ஒரு பணிதான் உள்ளது: ஒரு டிஸ்க் செயலிழந்தாலோ அல்லது மாற்றப்பட்டாலோ, சர்வர் தொடர்ந்து இயங்குவதை உறுதி செய்வது. அந்தப் பணி 'கிடைக்கும் தன்மை' (availability) சார்ந்தது; ஆனால் கிடைக்கும் தன்மை என்பது 'பாதுகாப்பு' (safety) அல்ல.
RAID உங்கள் எழுதும் தரவுகளை (writes) நகலெடுக்கிறது. rm -rf /srv என்பது ஒரு எழுதும் செயல்பாடு. மிரர் செய்யப்படும் இரண்டு பகுதிகளிலும் ஒரே மில்லி விநாடியில் ஒரு கோப்பு நீக்கப்பட்டால், அந்த array அதன் பிறகு தன்னைச் சரியாக இருப்பதாகவே காட்டும்.
இந்த வாக்கியத்தை நினைவில் கொள்ளுங்கள். இந்தப் பக்கத்தின் மீதமுள்ள பகுதிகள், ஒவ்வொரு RAID நிலையும் எத்தகைய பாதிப்புகளைத் தாங்கும் மற்றும் ஒவ்வொரு எழுதும் செயல்பாட்டிற்கும் அது உங்களுக்கு என்ன செலவை ஏற்படுத்தும் என்பதை விளக்குகின்றன. கடைசிப் பிரிவுகளில், நீங்கள் வைத்திருக்கும் மெஷினில் ஒரு array-ன் நிலையைச் சரிபார்க்கும் கட்டளைகளும், RAID இதுவரை ஈடுசெய்யாத தோல்விகளும் கொடுக்கப்பட்டுள்ளன.
Hosting வாங்குபவர் உண்மையில் சந்திக்கும் நிலைகள்: 1, 5, 6 மற்றும் 10
ஒரு திட்டப் பக்கம் (plan page) ஒரு எண்ணைக் குறிப்பிட்டு அதோடு நின்றுவிடுகிறது. அந்த எண் இரண்டு கேள்விகளுக்குப் பதிலளிக்கிறது: எத்தனை drives செயலிழக்க முடியும், மற்றும் ஒவ்வொரு write-க்கும் என்ன செலவாகும்.
RAID 1 என்பது ஒரு mirror ஆகும். இரண்டு drives ஒரே மாதிரியான blocks-ஐ வைத்திருக்கும். ஒவ்வொரு write-ம் இரண்டிற்கும் செல்லும். ஏதேனும் ஒரு drive-லிருந்து read செய்ய முடியும். ஒரு drive செயலிழந்தாலும் தரவு இழப்பு ஏற்படாது, மேலும் மொத்த கொள்ளளவில் பாதி மட்டுமே பயன்படுத்தக்கூடியதாக இருக்கும். இதில் parity கணக்கிட வேண்டியதில்லை என்பதால், write path மிகக் குறுகியது.
RAID 5 என்பது ஒரு stripe-க்கு ஒரு parity block கொண்ட striping ஆகும். n எண்ணிக்கையிலான drives இருந்தால், n-1 drives-ன் கொள்ளளவு கிடைக்கும், மேலும் இந்த array சரியாக ஒரு தோல்வியை மட்டுமே தாங்கும். Parity ஒரு குறிப்பிட்ட drive-ல் மட்டும் இருக்காது. அது அனைத்து drives-களிலும் சுழற்சி முறையில் இருப்பதால், ஒவ்வொரு drive-ம் தரவு மற்றும் parity ஆகிய இரண்டையும் கொண்டிருக்கும்.
RAID 6 ஒவ்வொரு stripe-க்கும் இரண்டாவது, சுதந்திரமான parity block-ஐச் சேர்க்கிறது, இது பொதுவாக P மற்றும் Q என்று அழைக்கப்படுகிறது. இது ஒரே நேரத்தில் எந்த இரண்டு drives செயலிழந்தாலும் தாங்கும். இது கேட்பதை விட முக்கியமானது, ஏனெனில் முதல் தோல்வியைச் சரிசெய்யும்போதே பெரும்பாலும் இரண்டாவது தோல்வி ஏற்படுகிறது.
RAID 10 என்பது mirrors-ன் ஒரு stripe ஆகும். Drives ஜோடிகளாக mirror செய்யப்படுகின்றன, தரவு அந்த ஜோடிகளுக்கு இடையே பரப்பப்படுகிறது. பயன்படுத்தக்கூடிய கொள்ளளவு மொத்த கொள்ளளவில் பாதி, இது RAID 1-க்கு சமமானது, அதனுடன் striping-ன் parallelism-ம் இணைகிறது.
இதை RAID 1+0 என்றும் எழுதுவதைக் காண்பீர்கள், இதுவே சரியான விளக்கம்: முதலில் mirror, பிறகு அந்த mirrors-க்கு இடையே stripe. RAID 0+1 என்பது மற்றொரு வரிசை, முதலில் stripe செய்துவிட்டு பிறகு இரண்டு stripes-ஐ mirror செய்வது. இது மோசமானது, ஏனெனில் ஒரு drive தோல்வியடைந்தால் முழு stripe-ம் சேவையிலிருந்து நீக்கப்படும், மேலும் பழுதுபார்ப்பின் போது மறுபக்கத்திலுள்ள அனைத்தையும் நகலெடுக்க வேண்டியிருக்கும்.
Linux ஒரு சிறப்பு வகை, இதைப் புரிந்துகொள்வது அவசியம். Kernel-ன் raid10 என்பது இரண்டு அடுக்குகளைக் கொண்டதற்குப் பதிலாக ஒரே தன்மையைக் கொண்டது, எனவே இது ஒற்றைப்படை எண்ணிக்கையிலான drives-ல் இயங்குகிறது மற்றும் nested setup-ல் சாத்தியமில்லாத layouts-ஐ (near, far, offset) கொண்டுள்ளது. இதனால்தான் Linux box-ல் உள்ள status line இரண்டு arrays-ஐக் குறிப்பிடுவதற்குப் பதிலாக 2 near-copies என்று காட்டுகிறது.
இந்த விளக்கப்படத்தின் தரவு
[
{
"label": "RAID 1 (eight copies)",
"usable_tb": 1,
"worst_case_drives_lost": 7,
"best_case_drives_lost": 7
},
{
"label": "RAID 5",
"usable_tb": 7,
"worst_case_drives_lost": 1,
"best_case_drives_lost": 1
},
{
"label": "RAID 6",
"usable_tb": 6,
"worst_case_drives_lost": 2,
"best_case_drives_lost": 2
},
{
"label": "RAID 10",
"usable_tb": 4,
"worst_case_drives_lost": 1,
"best_case_drives_lost": 4
}
]எட்டு 1 TB drives, RAID 5-ன் கீழ் 7 TB பயன்படுத்தக்கூடிய இடத்தையும், RAID 10-ன் கீழ் 4 TB இடத்தையும் தருகின்றன. இந்த இடைவெளி உண்மையான பண இழப்பு, இதனால்தான் parity தொடர்ந்து பரிந்துரைக்கப்படுகிறது. RAID 6 எந்தவொரு அமைப்பிலும் 2 தோல்விகளைத் தாங்கும். RAID 10 1 தோல்விகளை மட்டுமே உறுதி செய்கிறது, ஏனெனில் ஏற்கனவே செயலிழந்த drive-ன் ஜோடி drive-ல் ஏற்படும் இரண்டாவது தோல்வியே ஆபத்தானது. எந்த இரண்டு தோல்விகளும் ஒரே ஜோடியைப் பாதிக்காதபோது இது 4 தோல்விகள் வரை தாங்கும், இது வடிவமைப்பின் சிறப்பம்சத்தை விட அதிர்ஷ்டத்தையே சார்ந்தது.
ஒவ்வொரு எழுதும் செயல்பாட்டிற்கும் ஒவ்வொரு நிலையின் செலவு
ஒரு mirror-க்கு செய்யப்படும் எழுதும் செயல்பாடு, இரண்டு எழுதும் செயல்பாடுகளாகக் கருதப்படுகிறது; இவை இரண்டு உறுப்பினர்களுக்கும் ஒரே நேரத்தில் அனுப்பப்படுகின்றன. ஒரு parity stripe-க்கு எழுதும் செயல்பாடு அதிக வேலைப்பளுவைக் கொண்டது, ஏனெனில் அந்த stripe-க்கான parity block இப்போது தவறாகிவிடுகிறது, அதை மீண்டும் கணக்கிட வேண்டும்.
Read-modify-write செயல்பாட்டிற்கு, controller முதலில் பழைய தரவையும் (old data) பழைய parity-யையும் வாசிக்கும். RAID 5-ல் cache செய்யப்படாத ஒரு single-block overwrite என்பது read, read, write, write என மாறும். RAID 6 இரண்டு parity block-களைப் பராமரிக்கிறது, எனவே read-modify-write என்பது read, read, read, write, write, write என மாறும். Linux, reconstruct-write முறையையும் பயன்படுத்துகிறது; இதில் parity-யைக் கணக்கிட மாற்றப்படாத தரவுகள் வாசிக்கப்படுகின்றன. மூன்று drive-களைக் கொண்ட RAID 5-ல், அந்த overwrite-க்கு ஒரு தரவு வாசிப்பும் (data read) இரண்டு எழுதும் செயல்பாடுகளும் தேவைப்படும்; நான்கு drive-களைக் கொண்ட RAID 6-ல், ஒரு தரவு வாசிப்பும் மூன்று எழுதும் செயல்பாடுகளும் தேவைப்படும். நான்கு மற்றும் ஆறு என்பது read-modify-write எண்ணிக்கைகள் ஆகும், இவை ஒவ்வொரு சிறிய random write-க்கும் நிலையான செலவுகள் அல்ல.
இந்த விளக்கப்படத்தின் தரவு
[
{
"label": "RAID 1 (2 drives)",
"write_ops_per_host_write": 2,
"drives_read_to_rebuild": 1
},
{
"label": "RAID 5 (8 drives)",
"write_ops_per_host_write": 4,
"drives_read_to_rebuild": 7
},
{
"label": "RAID 6 (8 drives)",
"write_ops_per_host_write": 6,
"drives_read_to_rebuild": 7
},
{
"label": "RAID 10 (8 drives, fixed mirror pairs)",
"write_ops_per_host_write": 2,
"drives_read_to_rebuild": 1
}
]Cache செய்யப்படாத ஒரு single-block read-modify-write, RAID 6-ல் 6 சாதன செயல்பாடுகளைச் செலவாகக் கொள்கிறது, அதே சமயம் இரண்டு நகல்களைக் கொண்ட RAID 10-ல் இது 2 ஆக உள்ளது. இந்த எண்ணிக்கைகள் latency-ல் உள்ள வித்தியாசத்தை முழுமையாகக் காட்டவில்லை. இரண்டு mirror எழுதும் செயல்பாடுகளும் இணையாக (parallel) நடப்பதால், இரண்டில் மெதுவானது எதுவோ அதற்காகவே guest காத்திருக்க வேண்டும். Read-modify-write பாதையில் ஒரு வாசிப்பு செயல்பாடு உள்ளது; புதிய parity கணக்கிடப்படுவதற்கு முன்பு அது முடிவடைய வேண்டும். எனவே, guest ஒரு வாசிப்புக்கும் பின் ஒரு எழுதும் செயல்பாட்டுக்கும் அடுத்தடுத்து காத்திருக்க வேண்டும். பிஸியான host-ல், அந்த வாசிப்பு செயல்பாடு மற்ற அனைவரின் I/O வரிசைக்கும் பின்னால் காத்திருக்கும்.
இதில் ஒரு முக்கியமான விதிவிலக்கு உள்ளது. ஒரு முழு stripe-ஐ நிரப்பும் அளவுக்குப் பெரியதாக இருக்கும் எழுதும் செயல்பாட்டிற்கு பழைய தரவு தேவையில்லை, ஏனெனில் stripe-ல் உள்ள ஒவ்வொரு block-ம் மாற்றப்படுகிறது. Parity ஏற்கனவே நினைவகத்தில் (memory) உள்ளவற்றிலிருந்து கணக்கிடப்படுகிறது. இதனால் RAID 5-க்கு stripe ஒன்றுக்கு ஒரு parity write-ம், RAID 6-க்கு இரண்டு parity write-ம் மட்டுமே கூடுதல் சுமையாக இருக்கும்; முன்கூட்டியே வாசித்தல் (prereads) தேவைப்படாது. இதனால்தான் sequential benchmark-ல் RAID 5 நன்றாகத் தெரிவதும், பல பயனர்களிடமிருந்து வரும் சிறிய எழுதும் செயல்பாடுகள் கலந்த சுமையின் கீழ் மோசமாகச் செயல்படுவதும் நிகழ்கிறது. நீங்கள் உண்மையில் இயக்கும் முறையைச் சோதிக்கவும்: VPS disk-ஐ முறையாக benchmarking செய்தல் என்பது ஒரு பெரிய dd மூலம் அல்லாமல், யதார்த்தமான queue depth-ல் random I/O-வைச் சோதிப்பதாகும்.
rebuild ஏன் ஆபத்தானது
ஒரு முழுமையான RAID 5 rebuild, விடுபட்ட drive-ஐ மற்ற அனைத்து drive-களிலிருந்தும் மீண்டும் கட்டமைக்க வேண்டும். எனவே, எட்டு-drive கொண்ட உதாரணத்தில், முதல் block முதல் கடைசி வரை 7 இயங்கும் drive-களை அது வாசிக்கிறது. நிலையான இரண்டு-நகல் mirror ஜோடிகளுடன், ஒரு RAID 10 rebuild 1-ஐ மட்டுமே வாசிக்கிறது: அதாவது செயலிழந்த drive-ன் mirror partner-ஐ மட்டும் வாசிக்கும், வேறு எதையும் வாசிக்காது. பிற Linux RAID10 அமைப்புகள் நகல்களை வேறுவிதமாகப் பரப்புகின்றன: மூன்று-சாதன near layout-ல் ஒரு உறுப்பினரை rebuild செய்ய, எஞ்சியிருக்கும் இரண்டு உறுப்பினர்களும் வாசிக்கப்படுகின்றன.
இதிலிருந்து இரண்டு செலவுகள் ஏற்படுகின்றன. முதலாவது நேரம், ஏனெனில் rebuild-ன் வேகம் எஞ்சியிருக்கும் drive-கள், மறுசீரமைப்பு வேலை மற்றும் recovery speed இலக்குகளைப் பொறுத்தது. இரண்டாவது சுமை. ஒரு parity rebuild, I/O-வை எஞ்சியிருக்கும் drive-கள் முழுவதும் பரப்புகிறது. நிலையான mirror ஜோடிகளுடன், ஒரு RAID 10 rebuild அந்த I/O-வை ஒரு ஜோடியின் மீது மட்டும் குவிக்கிறது; பகிரப்பட்ட controller மற்றும் host வளங்கள் மற்ற ஜோடிகளையும் பாதிக்கின்றன.
அதே கால இடைவெளியில் ஒரு துல்லியத்தன்மை ஆபத்தும் உள்ளது. ஒரு drive செயலிழந்த RAID 5 array-ல் redundancy இல்லை, எனவே எஞ்சியிருக்கும் drive-ல் எங்கு ஒரு unreadable sector இருந்தாலும் அதை மீட்க முடியாது. ஒரு rebuild என்பது ஒவ்வொரு sector-ஐயும் வாசிக்கும் ஒரே செயல்பாடாகும், ஒரு வருடமாக யாரும் தொடாத sector-களும் இதில் அடங்கும். வெளியிடப்பட்ட datasheet புள்ளிவிவரங்களின்படி, ஒரு consumer hard drive-ல் 10^14 bits வாசிப்புக்கு ஒரு unrecoverable read error ஏற்படலாம், enterprise NVMe drive-ல் 10^17 அல்லது அதற்கு மேலான அளவில் ஒரு error ஏற்படலாம். இவை உற்பத்தியாளரின் விவரக்குறிப்புகள், அளவீடுகள் அல்ல. இருப்பினும், RAID 5 rebuild தோல்வியடையும் என்ற பழைய எச்சரிக்கை ஏன் பெரிய spinning disk-களைப் பற்றி எழுதப்பட்டது என்பதையும், NVMe-ல் அது ஏன் குறைவான பாதிப்பை ஏற்படுத்துகிறது என்பதையும் இந்த விகிதம் விளக்குகிறது. சுமை குறித்த வாதம் எந்த ஊடகத்திற்கும் பொருந்தும்.
rebuild செய்வதற்கு முன்பே scrubbing மூலம் மறைந்திருக்கும் பிழைகளைக் கண்டறியவும். Debian மற்றும் Ubuntu ஆகியவை md array-களுக்கு அவ்வப்போது scrub செய்யும் வசதியை வழங்குகின்றன, அதன் செயல்முறை பதிப்புகளுக்கு ஏற்ப மாறுபடும். எனவே உங்களிடம் எது உள்ளது என்பதைச் சரிபார்த்து, கைமுறையாக ஒரு pass-ஐத் தொடங்கவும்.
systemctl list-timers --all | grep -i mdcheck
ls -l /etc/cron.d/mdadm
echo check | sudo tee /sys/block/md0/md/sync_action
cat /sys/block/md0/md/mismatch_cntsync_action, pass முடிந்ததும் idle-க்குத் திரும்பும், மேலும் mismatch_cnt என்பது 0-ஐக் காட்ட வேண்டும். mirror-ல் பூஜ்ஜியத்திற்கு மேல் உள்ள எண், இரண்டு பாதிகளும் ஒத்துப்போகவில்லை என்பதைக் குறிக்கிறது. checksum இல்லாததால், எது சரியானது என்று kernel-ஆல் சொல்ல முடியாது. சில முரண்பாடுகள் பாதிப்பில்லாதவை, swap partitions இதற்குப் பொதுவான காரணம்: kernel ஒரு page-ஐ எழுதும் போது, அது உள்ளுக்குள் மாறக்கூடும். data array-ல் எண்ணிக்கை அதிகரித்தால் விசாரணை தேவை; அந்த எண்ணிக்கை மட்டும் எந்த drive-ஐ மாற்ற வேண்டும் என்று அடையாளம் காட்டாது.
NVMe-க்கு VPS வழங்குநர்கள் ஏன் RAID 10-ஐ தரநிலையாகப் பயன்படுத்துகிறார்கள்
ஒரு hypervisor node ஒரே ஒரு பணியை மட்டும் செய்வதில்லை. அது தொடர்பில்லாத பல டஜன் virtual machine-களை இயக்குகிறது. அவற்றின் I/O கோரிக்கைகள் ஒன்றோடொன்று கலந்து, சிறிய அளவிலான எழுதும் செயல்பாடுகளாக (small writes) வருகின்றன; அவற்றுக்கிடையே எந்தவிதமான locality-யும் இருப்பதில்லை. இந்தச் சூழலில்தான் parity read-modify-write சுழற்சி அதிகச் சுமையை ஏற்படுத்துகிறது; ஒரு பகிரப்பட்ட node-ல் நாள் முழுவதும் இத்தகைய செயல்பாடுகளே நடக்கின்றன.
Rebuild செயல்பாட்டைக் கருத்தில் கொண்டால், இந்தத் தேர்வு ஏன் சிறந்தது என்பது விளங்கும். Parity அடிப்படையிலான node-ல் ஒரு drive செயலிழந்தால், மீதமுள்ள அனைத்து drive-களிலும் reconstruction பணி சுமையை ஏற்படுத்தும். ஆனால், RAID 10-ல் mirror ஜோடிகள் இருப்பதால், ஒரு drive செயலிழந்தால் அந்த குறிப்பிட்ட ஜோடியில் மட்டுமே rebuild I/O நடக்கும். மற்ற செயல்பாடுகள் நடக்கும்போது Linux MD இந்த recovery வேகத்தைக் குறைக்கும். வழங்குநர்கள் latency அதிகரிக்காத சேவையை விற்பனை செய்கிறார்கள்; எனவே, அவர்கள் சேமிப்புத் திறனை (capacity) தியாகம் செய்து இதைச் சாதிக்கிறார்கள்: மொத்த raw NVMe-ல் பாதி mirror-க்காகப் பயன்படுத்தப்படுகிறது.
Drive-களின் அளவு அதிகரிப்பதும் இதே முடிவை எடுக்க வைக்கிறது. Drive-கள் பெரியதாகும்போது rebuild-க்கு எடுக்கும் நேரம் அதிகரிக்கிறது. RAID 5-ல் இந்த நேரத்தில் கூடுதல் சுமை ஏற்படுவதுடன், எந்தவிதமான redundancy-யும் இருக்காது; RAID 6 கூடுதல் drive செயலிழப்பைத் தாங்கும். இதனால்தான் virtualization-க்கான ZFS deployments-ல் wide raidz-க்கு பதிலாக mirrored vdevs பயன்படுத்தப்படுகின்றன: ஒரு mirror resilver செயல்பாட்டில், பயன்பாட்டில் உள்ள blocks மட்டுமே ஒரு ஜோடியில் நகலெடுக்கப்படும்.
இதன் பொருள் RAID 10 எல்லா இடங்களிலும் சரியானது என்பதல்ல. ஒரு backup target-ல் நீண்ட sequential தரவுகள் எழுதப்படுகின்றன, அவை அரிதாகவே வாசிக்கப்படுகின்றன; எனவே அங்கு RAID 6 சிறந்த தேர்வாகும். அது இரண்டு தோல்விகளைத் தாங்குவதுடன், அதிகப்படியான சேமிப்புத் திறனையும் வழங்குகிறது. RAID-ன் எண்ணிக்கையை விட, அந்த workload-ன் தன்மையே முடிவைத் தீர்மானிக்கிறது. நீங்கள் இன்று தேர்ந்தெடுக்கும் திட்டத்திற்கு, RAID layout-ஐ விட, பயன்படுத்தப்படும் medium முக்கியமானது; SATA SSD-லிருந்து NVMe-க்கு மாறுவது என்பது எந்தவொரு RAID மாற்றத்தை விடவும் பெரிய தாக்கத்தை ஏற்படுத்தும்.
/proc/mdstat-ஐ எவ்வாறு வாசிப்பது
நீங்கள் சொந்தமாக நிர்வகிக்கும் array உள்ள ஒரு இயந்திரத்தில் இவற்றை இயக்கவும்: ஒரு dedicated server, வீட்டில் உள்ள ஒரு கணினி, அல்லது நீங்களே கட்டமைத்த இரண்டு volumes கொண்ட VPS. உங்கள் வெளியீட்டை நீங்களே வாசியுங்கள். கீழே உள்ள தொகுதிகள் உதாரணங்கள்; உங்கள் கணினியில் வரும் வெளியீட்டுடன் ஒப்பிட்டுப் பார்க்க இவை உதவும்.
cat /proc/mdstat
sudo mdadm --detail /dev/md0
lsblk -o NAME,SIZE,TYPE,MOUNTPOINTSசரியாக இயங்கும் நான்கு drive-களைக் கொண்ட RAID 10 அமைப்பு இதைப் போன்ற வெளியீட்டைத் தரும்.
Personalities : [raid1] [raid10]
md0 : active raid10 nvme3n1p3[3] nvme2n1p3[2] nvme1n1p3[1] nvme0n1p3[0]
3906764800 blocks super 1.2 512K chunks 2 near-copies [4/4] [UUUU]
bitmap: 0/30 pages [0KB], 65536KB chunk
unused devices: <none>அதில் உள்ள ஒவ்வொரு பகுதியும் தகவல்களைக் கொண்டுள்ளது.
Personalitiesஎன்பது இயங்கும் kernel-ல் ஏற்றப்பட்டுள்ள md modules-களைப் பட்டியலிடுகிறது.raid10அங்கு காணப்படுவது, அந்த code கிடைக்கிறது என்பதை மட்டுமே குறிக்கும், வேறு எதையும் அல்ல.md0 : active raid10என்பது array device, அதன் நிலை மற்றும் அதன் level ஆகியவற்றைக் குறிக்கும்.- அதற்குப் பின் வரும் பெயர்கள் அதன் உறுப்பினர்கள் (members). சதுர அடைப்புக்குறிக்குள் உள்ள எண், array metadata-வில் அந்த device-ன் குறியீடு (index) ஆகும்; இது வரியில் உள்ள அதன் இடமோ அல்லது எப்போதும் அதன் slot எண்ணோ அல்ல.
- ஒரு drive-ஐ மாற்றிய பிறகு, புதிய உறுப்பினர் பொதுவாக அது நிரப்பும் slot-ஐ விட அதிக குறியீட்டையே வைத்திருக்கும், எனவே
nvme4n1p3[4]என்பது slot 2-ல் இருக்கலாம்.mdadm --detailஅதன்RaidDeviceநெடுவரிசையில் உண்மையான slot-ஐ அச்சிடுகிறது, எனவே வேறுபாடு முக்கியமாக இருக்கும்போது அதைப் பயன்படுத்தவும். - ஒரு உறுப்பினருக்குப் பின் வரும்
(F)என்பது அது பழுதடைந்துள்ளது என்பதைக் குறிக்கும்.(S)என்பது spare: அதாவது அது அங்கேயே உள்ளது, சும்மா இருக்கிறது, ஏதேனும் பழுதடையும் வரை காத்திருக்கிறது. 3906764800 blocks super 1.2என்பது 1 KiB தொகுதிகளில் பயன்படுத்தக்கூடிய அளவு, அதைத் தொடர்ந்து metadata வடிவம் உள்ளது.512K chunks 2 near-copiesஎன்பது stripe chunk அளவு மற்றும் RAID 10 அமைப்பு; இது ஒவ்வொரு தொகுதியின் இரண்டு பிரதிகளை அருகருகே வைத்திருக்கும்.[4/4]என்பது array எதிர்பார்க்கும் உறுப்பினர்களின் எண்ணிக்கை, அதைத் தொடர்ந்து தற்போது sync-ல் உள்ள எண்ணிக்கை உள்ளது.[UUUU]என்பது ஒவ்வொரு slot-க்கும் ஒரு குறியீடு, slot வரிசையில் இருக்கும்.Uஎன்பது சரியாக இயங்கி sync-ல் உள்ள slot._என்பது எந்த வேலையும் செய்யாத slot.bitmap:என்பது write intent bitmap. எந்தப் பகுதிகள் எழுதப்படுகின்றன என்பதை இது பதிவு செய்கிறது, இதனால் வெளியேறி மீண்டும் வரும் உறுப்பினர் முழு drive-ஐயும் sync செய்வதற்குப் பதிலாக அந்தப் பகுதிகளை மட்டும் sync செய்யும்.
ஏதேனும் தவறு நடக்கும்போது [4/3] மற்றும் [UU_U] எதைக் குறிக்கின்றன
பழுதடைந்த array இதைப் போலத் தோன்றும்.
md0 : active raid10 nvme3n1p3[3] nvme2n1p3[2](F) nvme1n1p3[1] nvme0n1p3[0]
3906764800 blocks super 1.2 512K chunks 2 near-copies [4/3] [UU_U]இரண்டு அடைப்புக்குறிகளையும் சேர்த்து வாசிக்கவும். [4/3] என்பது நான்கு slot-களில் ஒன்று செயல்படவில்லை என்று கூறுகிறது. [UU_U] என்பது எது பழுதடைந்துள்ளது என்று கூறுகிறது; underscore மூன்றாவது குறியீடாக இருப்பதால், slot 2 பழுதடைந்துள்ளது (slot-கள் பூஜ்ஜியத்திலிருந்து எண்ணப்படுகின்றன). பழுதடைந்த drive இன்னும் இணைக்கப்பட்டிருக்கும் வரை மட்டுமே (F) flag அந்த device-ன் பெயரைக் காட்டும். அதை இயந்திரத்திலிருந்து அகற்றிவிட்டால், வரியிலிருந்து அந்தப் பெயர் மறைந்துவிடும், ஆனால் underscore அப்படியே இருக்கும்.
இவை அனைத்திலும் array தொடர்ந்து இயங்கும், RAID 10-ல் இது பெரும்பாலும் முழு வேகத்தில் இயங்கும், அதனால்தான் யாரும் இதை உணர்வதில்லை. ஏதேனும் ஒன்று உங்களுக்குத் தெரிவிக்க வேண்டும்.
grep -i mailaddr /etc/mdadm/mdadm.conf
sudo mdadm --monitor --scan --oneshot --test
systemctl list-units --all | grep -i mdmdadm தொகுப்பு ஒரு monitor daemon-ஐ நிறுவுகிறது, இது /etc/mdadm/mdadm.conf-லிருந்து MAILADDR-ஐ வாசிக்கும். வெளியீடுகளுக்கு இடையே unit பெயர் மாறியுள்ளதால், யூகிக்காமல் கடைசி கட்டளையைப் பயன்படுத்தி அதைக் கண்டறியவும். --test இயக்கம் ஒவ்வொரு array-க்கும் உடனடியாக ஒரு செய்தியை அனுப்பும். அதற்குப் பிறகு inbox காலியாக இருந்தால், mail பாதை பழுதடைந்துள்ளது என்று அர்த்தம்; எனவே உங்களுக்குத் தேவையான செய்தியும் அதே வழியில் தொலைந்திருக்கும்.
மாற்றீடு (replacement) rebuild ஆகும்போது, array-க்குக் கீழே ஒரு progress வரி தோன்றும்.
md0 : active raid10 nvme4n1p3[4] nvme3n1p3[3] nvme1n1p3[1] nvme0n1p3[0]
3906764800 blocks super 1.2 512K chunks 2 near-copies [4/3] [UU_U]
[==>..................] recovery = 12.4% (242012928/1953382400) finish=63.1min speed=452000K/secrecovery என்பது மாற்றீடு செய்யப்பட்ட drive-ல் நடக்கும் rebuild ஆகும். resync என்பது consistency pass, இதில் ஆரம்ப pass மற்றும் முறையற்ற shutdown-க்குப் பிறகு நடக்கும் மீட்பு ஆகியவை அடங்கும். check என்பது நீங்கள் மேலே தூண்டிய scrub ஆகும். அடைப்புக்குறிக்குள் உள்ள ஜோடி, device-க்குரிய மொத்த அளவோடு ஒப்பிடும்போது 1 KiB தொகுதிகளில் முன்னேற்றத்தைக் குறிக்கிறது, மேலும் finish என்பது தற்போதைய வேகத்தில் kernel கணிக்கும் நேரம் ஆகும். Linux MD, /proc/sys/dev/raid/speed_limit_min மற்றும் speed_limit_max ஆகியவற்றை மீட்பு வேக இலக்குகளாகப் பயன்படுத்துகிறது, array-க்குரிய மாற்றங்கள் sync_speed_min மற்றும் sync_speed_max-ல் உள்ளன. இயல்புநிலை அதிகபட்ச இலக்கு ஒரு device-க்கு 200,000 KiB/s ஆகும்; இந்த இலக்குகள் மீட்புப் பணியை production I/O-க்கு விட்டுக்கொடுக்க அனுமதிக்கின்றன, இவை கடினமான வேகக் கட்டுப்பாடுகள் அல்ல.
Rebuild-ன் போது முழுமையான mdadm --detail
/dev/md0:
Version : 1.2
Creation Time : Tue Mar 10 09:14:22 2026
Raid Level : raid10
Array Size : 3906764800 (3.64 TiB 4.00 TB)
Used Dev Size : 1953382400 (1.82 TiB 2.00 TB)
Raid Devices : 4
Total Devices : 4
Persistence : Superblock is persistent
Update Time : Wed Aug 5 11:02:41 2026
State : clean, degraded, recovering
Active Devices : 3
Working Devices : 4
Failed Devices : 0
Spare Devices : 1
Layout : near=2
Chunk Size : 512K
Rebuild Status : 12% complete
Name : storage:0
Events : 4184
Number Major Minor RaidDevice State
0 259 3 0 active sync set-A /dev/nvme0n1p3
1 259 7 1 active sync set-B /dev/nvme1n1p3
4 259 11 2 spare rebuilding /dev/nvme4n1p3
3 259 15 3 active sync set-B /dev/nvme3n1p3Number நெடுவரிசை என்பது /proc/mdstat-ல் அடைப்புக்குறிக்குள் அச்சிடப்பட்ட metadata குறியீடு ஆகும். RaidDevice நெடுவரிசை என்பது slot, இது [UU_U] சரத்தில் உள்ள இடமாகும். இங்கே அவை வேறுபடுகின்றன, ஏனெனில் device 4 என்பது slot 2-ல் இருந்த drive-ஐ மாற்றியது. set-A மற்றும் set-B ஆகியவை ஒவ்வொரு mirror-ன் இரண்டு பாதிகளையும் பெயரிடுகின்றன, எனவே ஒரே ஜோடியில் உள்ள set-A-ன் உறுப்பினர் மற்றும் set-B-ன் உறுப்பினர் ஒரே தரவை வைத்திருக்கும்; அவற்றை ஒன்றாக இழக்கக்கூடாது.
நீங்கள் சொந்தமாக வைத்திருக்கும் array-ல் ஒரு drive-ஐ மாற்றுவது நான்கு கட்டளைகளைக் கொண்டது, கடைசி கட்டளை சரிபார்ப்புக்கானது.
sudo mdadm --manage /dev/md0 --fail /dev/nvme2n1p3
sudo mdadm --manage /dev/md0 --remove /dev/nvme2n1p3
sudo mdadm --manage /dev/md0 --add /dev/nvme4n1p3
cat /proc/mdstatமீட்பு வரி (recovery line) ஒன்று அல்லது இரண்டு வினாடிகளுக்குள் தோன்ற வேண்டும். மாற்றீடு செய்யப்படும் partition, mdadm --detail-லிருந்து Used Dev Size-ஐ விடப் பெரியதாக இருக்க வேண்டும்; சற்று சிறியதாக இருக்கும் partition not large enough to join array என்ற வடிவத்தில் ஒரு செய்தியுடன் நிராகரிக்கப்படும். புதிய drive-ஐச் சேர்ப்பதற்கு முன், பழைய drive-க்கு ஏற்ப அதை partition செய்யவும்.
VPS-க்குள் உங்களால் எதைப் பார்க்க முடியும், எதைப் பார்க்க முடியாது
பெரும்பாலான விருந்தினர் (guest) கணினிகளால் host-ன் RAID-ஐப் பார்க்க முடியாது, இது வடிவமைப்பிலேயே அவ்வாறு செய்யப்பட்டுள்ளது. Hypervisor உங்களுக்கு ஒரு virtual disk-ஐ மட்டுமே வழங்குகிறது. அந்த disk, NVMe drives கொண்ட RAID 10 தொகுப்பிலிருந்து பிரிக்கப்பட்டதா அல்லது ஒரே ஒரு drive-ல் உள்ளதா என்பது host-ன் பண்பாகும்; அது உங்கள் guest-க்குள் தெரியாது.
systemd-detect-virt
lsblk -d -o NAME,SIZE,ROTA,MODEL
cat /proc/mdstatsystemd-detect-virt கட்டளையானது KVM guest-ல் kvm-ஐயும், container-ல் lxc போன்ற container வகையையும், bare metal-ல் none-ஐயும் காட்டும். KVM guest-ல் பொதுவாக lsblk-ல் ஒரே ஒரு vda அல்லது sda மட்டுமே தெரியும். guest-க்குள் arrays எதுவும் இல்லாததால், /proc/mdstat-ல் எந்த arrays-ம் காட்டப்படாது.
Container அடிப்படையிலான VPS-ல் கிடைக்கும் தகவல்கள் நம்பகமானவை அல்ல. Containers-கள் host kernel-ஐப் பகிர்ந்துகொள்வதால், /proc-ன் சில பகுதிகள் namespaced செய்யப்படுவதில்லை. எனவே, அங்கு நீங்கள் வாசிக்கும் தகவல்கள் உங்கள் slice-ஐ விட host-ஐப் பற்றியதாக இருக்கலாம். உங்கள் storage-ஐப் பொறுத்தவரை எதையும் உண்மையாகக் கருத வேண்டாம். உங்கள் storage அமைப்பு என்னவென்று service provider-இடம் கேட்டுத் தெரிந்துகொள்ளுங்கள்; அது உங்களுக்கு முக்கியமென்றால், அதை எழுத்துப்பூர்வமாகப் பெற்றுக்கொள்ளுங்கள்.
உங்களுக்கு வழங்கப்பட்ட disk-ன் செயல்பாட்டை மட்டும் உங்களால் உள்ளிருந்து சரிபார்க்க முடியும். உங்கள் VPS disk உண்மையில் NVMe தானா என்பதைச் சரிபார்த்தல் பகுதியில் உண்மையான தகவல்களைத் தரும் கட்டளைகள் விளக்கப்பட்டுள்ளன. SSD VPS-ல் உண்மையில் என்ன உள்ளடங்கியுள்ளது பகுதியில், திட்டப் பக்கத்தில் (plan page) குறிப்பிடப்பட்டுள்ள லேபிள்களின் உண்மைத்தன்மை விளக்கப்பட்டுள்ளது.
உங்கள் VPS-க்குள் RAID-ஐ இயக்க வேண்டுமா?
பொதுவாகத் தேவையில்லை, இதற்குக் காரணம் failure domains ஆகும். நீங்கள் இரண்டு volumes-ஐ ஒரு VPS-உடன் இணைத்து mdadm மூலம் mirror செய்தால், அந்த இரண்டு volumes-ம் ஒரே physical array-ல், ஒரே node-ல், ஒரே power supply-ன் பின்னால் இருக்கலாம். நீங்கள் ஏற்கனவே பெற்றிருந்த redundancy-க்காக ஒவ்வொரு write-ன் செலவையும் இரண்டு மடங்காக்குவீர்கள், ஆனால் முக்கியமான ஒரு failure ஏற்படும்போது இரண்டு பிரதிகளையும் இழக்க நேரிடும்.
Volumes வெவ்வேறு failure domains-ல் இருப்பதாக உங்கள் provider ஆவணப்படுத்தியிருக்கும்போது, அல்லது நீங்கள் drives-ஐ நேரடியாகக் குறிப்பிடக்கூடிய dedicated server-ல் இருக்கும்போது இதைச் செய்வது பயனுள்ளது. மற்றபடி, இந்த முயற்சியை அந்த machine-ஐ விட்டு வெளியே செல்லும் பிரதிகளில் (copies) மேற்கொள்வது அதிகப் பலன் தரும்.
RAID எவற்றிலிருந்து உங்களைப் பாதுகாக்காது
RAID ஒரே ஒரு நிகழ்வை மட்டுமே கையாள்கிறது: ஒரு drive சரியாகச் செயல்படாமல் நின்றுவிடுவது. கீழே உள்ள அனைத்தும் முறையான write செயல்பாடுகள் என்பதால், array அவற்றை ஒவ்வொரு நகலிலும் செயல்படுத்தி, தன்னை ஆரோக்கியமானதாகவே காட்டிக்கொள்ளும்.
- நீக்கம் (Deletion). தவறான directory-ல்
rm -rfசெய்வது, அல்லது path-ல் variable-ஐ set செய்யாத ஒரு deploy script. Array இதை ஒரு முறையான write-ஆகக் கருதி, இரண்டு இடங்களிலும் செயல்படுத்திவிடும். - Ransomware. Encryption என்பது ஒரு write செயல்பாடு. ஆரோக்கியமான array ஒன்று, mirror-ன் இரண்டு பகுதிகளிலும் encrypted செய்யப்பட்ட கோப்பையே சேமிக்கும்.
- பழுதடைந்த application. உங்கள் database-ல் குப்பையான தரவுகளை எழுதும் ஒரு bug, அதே குப்பையை redundant drive-லும் எழுதிவிடும்.
- முழு node-ம் செயலிழத்தல். ஒரு host செயலிழப்பது அல்லது தவறுதலாக ஒரு account முடக்கப்படுவது. ஒரு array மிகச்சரியாக இருந்தாலும், அதை அணுக முடியாமல் போகலாம்.
- நீங்கள் செய்த தவறு. திங்கட்கிழமை நீங்கள் நீக்கிய கோப்பு, திங்கட்கிழமையே அனைத்து drive-களிலிருந்தும் நீக்கப்பட்டுவிடும். அதற்கு முன்னால் எடுக்கப்பட்ட ஒரு நகல் மட்டுமே அதை மீட்டெடுக்க உதவும்.
ஒரே storage-ல் எடுக்கப்படும் snapshots-ம் இதற்குத் தீர்வாகாது. அவை நீக்கத்தைத் தடுக்க உதவலாம், ஆனால் அவை எந்த array-ல் இருக்கின்றனவோ, அந்த array பழுதடைந்தால் அவையும் அழிந்துவிடும். ஒரு backup-ஐ உண்மையான backup-ஆக மாற்றுவது, அது வேறொரு இடத்தில் இருப்பதுதான். restic மூலம் server-க்கு வெளியே encrypted செய்யப்பட்ட backups என்பது இந்தப் பக்கத்தின் மற்றொரு பகுதி: ஒரு drive பழுதடைந்தாலும் array தொடர்ந்து சேவையை வழங்கும், அதே சமயம் array மகிழ்ச்சியுடன் செய்த ஒரு write செயல்பாட்டினால் தரவு சேதமடைந்தால், restic அதை மீட்டெடுத்துத் தரும்.
FAQ
RAID 10 இருந்தால் எனக்கு பேக்கப்கள் தேவையில்லையா?
இல்லை. ஒரு drive செயலிழக்கும்போது RAID 10 பாதுகாப்பளிக்கும். இது ஒவ்வொரு சரியான write-ஐயும் mirror-ன் இரு பகுதிகளிலும் பதிவு செய்யும்; எனவே, ஒரு கோப்பை நீக்கினாலோ அல்லது ransomware தாக்குதல் நடந்தாலோ, அந்த மாற்றங்கள் உடனடியாக redundant drive-க்கும் சென்றுவிடும். அதன் பார்வையில் எந்தப் பிழையும் நடக்காததால், array தன்னை 'clean' என்று காட்டும். எனவே, machine-க்கு வெளியே சேமிக்கப்படும் பேக்கப்கள் உங்களுக்குத் தேவை; மேலும், அவை சரியாக வேலை செய்கின்றனவா என்பதை உறுதிப்படுத்த அவ்வப்போது அவற்றை restore செய்து பார்க்க வேண்டும்.
VPS வழங்குநர்கள் ஏன் RAID 5 அல்லது RAID 6-க்கு பதிலாக RAID 10-ஐத் தேர்ந்தெடுக்கிறார்கள்?
இதற்கு இரண்டு காரணங்கள் உள்ளன, இரண்டுமே சிறிய random write செயல்பாடுகள் தொடர்பானவை. Cache செய்யப்படாத single-block read-modify-write முறையில், புதிய parity-ஐக் கணக்கிடுவதற்கு முன்பு பழைய தரவுகளையும் parity-யையும் படிக்க வேண்டும். இதற்கு RAID 5-ல் 4 செயல்பாடுகளும், RAID 6-ல் 6 செயல்பாடுகளும் தேவைப்படுகின்றன; ஆனால், இரண்டு நகல்களைக் கொண்ட mirror-ல் இதற்கு 2 செயல்பாடுகள் மட்டுமே தேவை. Reconstruct-write முறையில் மாற்றப்படாத தரவுகள் பயன்படுத்தப்படுகின்றன, மேலும் full-stripe write-களுக்கு பழைய தரவு அல்லது பழைய parity-ஐ முன்கூட்டியே படிக்க வேண்டிய அவசியமில்லை. முழுமையான RAID 5 rebuild-ன் போது, எஞ்சியிருக்கும் ஒவ்வொரு drive-ம் முழுமையாகப் படிக்கப்படும்; அதேசமயம், நிலையான mirror ஜோடிகளைக் கொண்ட வழக்கமான RAID 10, எஞ்சியிருக்கும் partner drive-லிருந்து தரவை நகலெடுக்கும்; பிற Linux RAID10 அமைப்புகள் பல source உறுப்பினர்களைப் பயன்படுத்துகின்றன. மற்ற செயல்பாடுகள் நடக்கும்போது Linux MD recovery வேகத்தைக் குறைக்கும். இதற்குப் பதிலாக, வழங்குநர்கள் சேமிப்புத் திறனில் பாதி இழப்பைச் சந்திக்கிறார்கள்: அதாவது, raw NVMe-ல் பாதி அளவு மட்டுமே கிடைக்கிறது.
/proc/mdstat-ல் [U_] அல்லது [UU_U] என்பதன் பொருள் என்ன?
ஒவ்வொரு குறியீடும் array-ல் உள்ள ஒரு slot-ஐக் குறிக்கும்; slot வரிசைப்படி ஒரு குறியீடு ஒரு slot-க்கு உரியது. U என்பது அந்த slot-ல் உள்ள உறுப்பினர் சரியாக இயங்குகிறது மற்றும் sync-ல் உள்ளது என்று பொருள். _ என்பது அந்த slot-ல் எதுவும் வேலை செய்யவில்லை என்று பொருள். இரண்டு drive கொண்ட mirror-ல் [U_] என்பது இரண்டாவது slot செயலிழந்துவிட்டது மற்றும் redundancy இல்லை என்று பொருள். இதை அதற்கு முன்னால் உள்ள ஜோடியுடன் சேர்த்துப் படிக்க வேண்டும்; உதாரணமாக, [4/3] என்பது array நான்கு உறுப்பினர்களை எதிர்பார்க்கிறது, ஆனால் மூன்று மட்டுமே உள்ளன என்று பொருள். slot வரிசையானது mdadm --detail-ன் RaidDevice column-உடன் ஒத்துப்போகும், வரியில் தோன்றும் device பெயர்களின் வரிசையுடன் அல்ல.
ஒரு RAID 10 array எத்தனை drive-களை இழக்க முடியும்?
நிலையான mirror ஜோடிகளைக் கொண்ட வழக்கமான இரண்டு-நகல் (two-copy) RAID 10-ல், எந்தவொரு அமைப்பிலும் ஒரு drive-ஐ இழக்கலாம். அதற்கு மேல் இழப்பு ஏற்பட்டால், அது எந்த drive-கள் செயலிழக்கின்றன என்பதைப் பொறுத்தது. ஒவ்வொரு mirror ஜோடியும் தனது இரண்டு உறுப்பினர்களில் ஒன்றை இழக்கலாம்; எனவே, எட்டு drive கொண்ட array-ல் எந்த இரண்டு drive-களும் ஒரே ஜோடியைச் சேர்ந்தவை அல்ல எனில், நான்கு drive-கள் வரை செயலிழந்தாலும் array இயங்கும். ஆனால், ஒரே ஜோடியில் இரண்டு drive-கள் செயலிழந்தால் array இயங்காது. எனவே, ஒரு drive-ஐ இழக்கலாம் என்பதை அடிப்படையாகக் கொண்டு திட்டமிடுங்கள்; அதற்கு மேல் நடப்பவை பாதுகாப்பாகக் கருதப்படாமல், அதிர்ஷ்டமாகக் கருதப்பட வேண்டும்.
எனது VPS-க்குள் mdadm மூலம் இரண்டு volumes-ஐ mirror செய்ய வேண்டுமா?
பொதுவாகத் தேவையில்லை. ஒரே VPS-ல் இணைக்கப்பட்ட இரண்டு volumes பெரும்பாலும் ஒரே host-ல் உள்ள ஒரே physical array-ல் தான் இருக்கும். எனவே, அவற்றை mirror செய்வது ஒவ்வொரு write செயல்பாட்டின் செலவையும் இரட்டிப்பாக்குமே தவிர, host-ன் சொந்த RAID ஏற்கனவே வழங்காத எந்தப் பாதுகாப்பையும் தராது. அந்த volumes வெவ்வேறு failure domains-ல் இருப்பதாக வழங்குநர் ஆவணப்படுத்தியிருந்தால் மட்டுமே இதைச் செய்வது பயனுள்ளது. இல்லையெனில், அந்த முயற்சியை machine-க்கு வெளியே செய்யப்படும் பேக்கப்களில் செலுத்துங்கள்.