ഹാഷ്ഗെറ്റ് - ഇത് സൌജന്യമാണ്, ഓപ്പൺ സോഴ്സ് ആണ് ഡ്യൂപ്ലിക്കേറ്റർ ബാക്കപ്പുകളുടെ വലുപ്പം ഗണ്യമായി കുറയ്ക്കാനും അതുപോലെ തന്നെ ഇൻക്രിമെന്റൽ, ഡിഫറൻഷ്യൽ ബാക്കപ്പ് സ്കീമുകളും മറ്റും സംഘടിപ്പിക്കാനും നിങ്ങളെ അനുവദിക്കുന്ന ആർക്കൈവറിന് സമാനമായ ഒരു യൂട്ടിലിറ്റിയാണ്.

സവിശേഷതകൾ വിവരിക്കുന്നതിനുള്ള ഒരു അവലോകന ലേഖനമാണിത്. ഹാഷ്‌ഗെറ്റിന്റെ യഥാർത്ഥ ഉപയോഗം (തികച്ചും ലളിതം) വിവരിച്ചിരിക്കുന്നു വായിക്കുക പദ്ധതിയും വിക്കി ഡോക്യുമെന്റേഷൻ.

താരതമ്യം

ഈ വിഭാഗത്തിന്റെ നിയമമനുസരിച്ച്, ഞാൻ ഉടൻ തന്നെ ഗൂഢാലോചന ആരംഭിക്കും - ഫലങ്ങൾ താരതമ്യം ചെയ്യുന്നു:

ഡാറ്റ സാമ്പിൾ
പായ്ക്ക് ചെയ്യാത്ത വലിപ്പം
.tar.gz
hashget.tar.gz

വേർഡ്പ്രസ്സ്-5.1.1
43 Mb
11 Mb (26%)
155 Kb ( 0.3% )

ലിനക്സ് കെർണൽ 5.0.4
934 Mb
161 Mb (20%)
4.7 Mb ( 0.5% )

Debian 9 (LAMP) LXC VM
724 Mb
165 Mb (23%)
4.1 Mb ( 0.5% )

അനുയോജ്യമായതും ഫലപ്രദവുമായ ബാക്കപ്പ് എന്തായിരിക്കണം എന്നതിന്റെ പശ്ചാത്തലം

പുതുതായി സൃഷ്ടിച്ച ഒരു വെർച്വൽ മെഷീന്റെ ബാക്കപ്പ് എടുക്കുമ്പോഴെല്ലാം, ഞാൻ എന്തെങ്കിലും തെറ്റ് ചെയ്യുകയാണെന്ന തോന്നൽ എന്നെ വേട്ടയാടിയിരുന്നു. “ഹലോ വേൾഡ്” എന്ന ടെക്‌സ്‌റ്റുള്ള എന്റെ വിലമതിക്കാനാകാത്തതും നശിപ്പിക്കാനാവാത്തതുമായ സർഗ്ഗാത്മകത ഒരു ഒറ്റ-വരി index.html ആയ സിസ്റ്റത്തിൽ നിന്ന് എനിക്ക് എന്തിനാണ് കനത്ത ബാക്കപ്പ് ലഭിക്കുന്നത്?

എന്തുകൊണ്ടാണ് എന്റെ ബാക്കപ്പിൽ 16 MB /usr/sbin/mysqld ഉള്ളത്? ഈ സുപ്രധാന ഫയൽ സൂക്ഷിക്കാനുള്ള ബഹുമതി ഈ ലോകത്ത് എനിക്കുണ്ട്, ഞാൻ പരാജയപ്പെട്ടാൽ അത് മനുഷ്യരാശിക്ക് നഷ്ടമാകുമോ? മിക്കവാറും ഇല്ല. ഇത് വളരെ വിശ്വസനീയമായ ഡെബിയൻ സെർവറുകളിലും (ഇതിന്റെ വിശ്വാസ്യതയും പ്രവർത്തന സമയവും എനിക്ക് നൽകാൻ കഴിയുന്നതുമായി താരതമ്യം ചെയ്യാൻ കഴിയില്ല), അതുപോലെ തന്നെ മറ്റ് അഡ്മിൻമാരുടെ ബാക്കപ്പുകളിലും (അതിൽ ദശലക്ഷക്കണക്കിന്) സംഭരിച്ചിരിക്കുന്നു. വിശ്വാസ്യത മെച്ചപ്പെടുത്തുന്നതിന് ഈ പ്രധാനപ്പെട്ട ഫയലിന്റെ 10+ 000st കോപ്പി സൃഷ്‌ടിക്കേണ്ടതുണ്ടോ?

പൊതുവെ ഹാഷ്ഗെറ്റ് ഈ പ്രശ്നം പരിഹരിക്കുകയും ചെയ്യുന്നു. പാക്ക് ചെയ്യുമ്പോൾ, അത് വളരെ ചെറിയ ബാക്കപ്പ് സൃഷ്ടിക്കുന്നു. അൺപാക്ക് ചെയ്യുമ്പോൾ - പൂർണ്ണമായും അൺപാക്ക് ചെയ്ത സിസ്റ്റം, അത് എന്തായിരിക്കുമെന്നതിന് സമാനമാണ് tar -c / tar -x. (മറ്റൊരു രീതിയിൽ പറഞ്ഞാൽ, ഇത് നഷ്ടമില്ലാത്ത പാക്കേജിംഗ് ആണ്)

ഹാഷ്‌ജെറ്റ് എങ്ങനെ പ്രവർത്തിക്കുന്നു

ഹാഷ്‌ജെറ്റിന് പാക്കേജ്, ഹാഷ്‌പാക്കേജ് എന്നീ ആശയങ്ങളുണ്ട്, അവയുടെ സഹായത്തോടെ അത് ഡ്യൂപ്ലിക്കേഷൻ നടത്തുന്നു.

പാക്കേജ് (പ്ലാസ്റ്റിക് സഞ്ചി). ഇന്റർനെറ്റിൽ നിന്ന് സുരക്ഷിതമായി ഡൗൺലോഡ് ചെയ്യാവുന്ന ഒരു ഫയൽ (സാധാരണയായി ഒരു .deb അല്ലെങ്കിൽ .tar.gz ആർക്കൈവ്), അതിൽ നിന്ന് ഒന്നോ അതിലധികമോ ഫയലുകൾ ലഭിക്കും.

ഹാഷ്പാക്കേജ് — പാക്കേജ് URL ഉം അതിൽ നിന്നുള്ള ഫയലുകളുടെ ഹാഷ് തുകകളും (sha256) ഉൾപ്പെടെ, ഒരു പാക്കേജിനെ പ്രതിനിധീകരിക്കുന്ന ഒരു ചെറിയ JSON ഫയൽ. ഉദാഹരണത്തിന്, 5 മെഗാബൈറ്റ് mariadb-server-core പാക്കേജിന്, ഹാഷ്പാക്കേജ് വലുപ്പം 6 കിലോബൈറ്റുകൾ മാത്രമാണ്. ഏകദേശം ആയിരം മടങ്ങ് കുറവ്.

ഡ്യൂപ്ലിക്കേഷൻ — ഡ്യൂപ്ലിക്കേറ്റ് ഫയലുകൾ ഇല്ലാതെ ഒരു ആർക്കൈവ് സൃഷ്ടിക്കുന്നു (യഥാർത്ഥ പാക്കേജ് എവിടെ നിന്ന് ഡൗൺലോഡ് ചെയ്യാമെന്ന് ഡ്യൂപ്ലിക്കേറ്ററിന് അറിയാമെങ്കിൽ, അത് ആർക്കൈവിൽ നിന്നുള്ള ഡ്യൂപ്ലിക്കേറ്റുകൾ കുറയ്ക്കുന്നു).

പാക്കേജിംഗ്

പാക്ക് ചെയ്യുമ്പോൾ, പാക്ക് ചെയ്തിരിക്കുന്ന ഡയറക്‌ടറിയിൽ നിന്നുള്ള എല്ലാ ഫയലുകളും സ്കാൻ ചെയ്യുന്നു, അവയുടെ ഹാഷ് തുകകൾ കണക്കാക്കുന്നു, കൂടാതെ അറിയപ്പെടുന്ന ഹാഷ്പാക്കേജുകളിലൊന്നിൽ തുക കണ്ടെത്തിയാൽ, ഫയലിനെക്കുറിച്ചുള്ള മെറ്റാഡാറ്റ (പേര്, ഹാഷ്, ആക്സസ് അവകാശങ്ങൾ മുതലായവ) സംരക്ഷിക്കപ്പെടും. ഒരു പ്രത്യേക ഫയലിൽ .hashget-restore.json, അതും ആർക്കൈവിൽ ഉൾപ്പെടുത്തും.

ലളിതമായ സാഹചര്യത്തിൽ, പാക്കേജിംഗ് തന്നെ ടാറിനേക്കാൾ സങ്കീർണ്ണമല്ല:

hashget -zf /tmp/mybackup.tar.gz --pack /path/to/data

പായ്ക്ക് ചെയ്യുന്നു

രണ്ട് ഘട്ടങ്ങളിലായാണ് അൺപാക്ക് ചെയ്യുന്നത്. ആദ്യം സാധാരണ ടാർ അൺപാക്കിംഗ്:

tar -xf mybackup.tar.gz -C /path/to/data

തുടർന്ന് നെറ്റ്‌വർക്കിൽ നിന്ന് പുനഃസ്ഥാപിക്കുക:

hashget -u /path/to/data

പുനഃസ്ഥാപിക്കുമ്പോൾ, ഹാഷ്‌ജെറ്റ് .hashget-restore.json ഫയൽ വായിക്കുകയും ആവശ്യമായ പാക്കേജുകൾ ഡൗൺലോഡ് ചെയ്യുകയും അവ അൺപാക്ക് ചെയ്യുകയും ആവശ്യമായ ഫയലുകൾ എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യുകയും ആവശ്യമായ ഉടമ/ഗ്രൂപ്പ്/അനുമതികൾ എന്നിവ ഉപയോഗിച്ച് ആവശ്യമായ പാതകളിൽ അവ ഇൻസ്റ്റാൾ ചെയ്യുകയും ചെയ്യുന്നു.

കൂടുതൽ ബുദ്ധിമുട്ടുള്ള കാര്യങ്ങൾ

മുകളിൽ വിവരിച്ചത് "ടാർ പോലെ വേണം, പക്ഷേ എന്റെ ഡെബിയൻ 4 മെഗാബൈറ്റിൽ പാക്ക് ചെയ്യാൻ" ഉള്ളവർക്ക് ഇതിനകം തന്നെ മതി. കൂടുതൽ സങ്കീർണ്ണമായ കാര്യങ്ങൾ പിന്നീട് നോക്കാം.

ഇൻഡെക്സിംഗ്

ഹാഷ്‌ജെറ്റിന് ഒരൊറ്റ ഹാഷ്‌പാക്കേജ് പോലും ഇല്ലെങ്കിൽ, അതിന് ഒന്നും ഡ്യൂപ്ലിക്കേറ്റ് ചെയ്യാൻ കഴിയില്ല.

നിങ്ങൾക്ക് ഒരു ഹാഷ്പാക്കേജ് സ്വമേധയാ സൃഷ്ടിക്കാനും കഴിയും (ലളിതമായി: hashget --submit https://wordpress.org/wordpress-5.1.1.zip -p my), എന്നാൽ കൂടുതൽ സൗകര്യപ്രദമായ മാർഗമുണ്ട്.

ആവശ്യമായ ഹാഷ്പാക്കേജ് ലഭിക്കുന്നതിന്, ഒരു ഘട്ടമുണ്ട് ഇൻഡെക്സിംഗ് (ഇത് കമാൻഡ് ഉപയോഗിച്ച് യാന്ത്രികമായി നടപ്പിലാക്കുന്നു --pack) ഒപ്പം ഹ്യൂറിസ്റ്റിക്സ്. ഇൻഡെക്‌സ് ചെയ്യുമ്പോൾ, ലഭ്യമായ എല്ലാ ഹ്യൂറിസ്റ്റിക്‌സിലും താൽപ്പര്യമുള്ള ഓരോ ഫയലിനും ഹാഷ്‌ജെറ്റ് “ഫീഡ്” നൽകുന്നു. ഒരു ഹാഷ്‌പാക്കേജ് സൃഷ്‌ടിക്കാൻ ഹ്യൂറിസ്റ്റിക്‌സിന് ഏത് പാക്കേജിനെയും സൂചികയിലാക്കാനാകും.

ഉദാഹരണത്തിന്, ഡെബിയൻ ഹ്യൂറിസ്റ്റിക് ഫയൽ /var/lib/dpkg/സ്റ്റാറ്റസ് ഇഷ്ടപ്പെടുകയും ഇൻസ്റ്റാൾ ചെയ്ത ഡെബിയൻ പാക്കേജുകൾ കണ്ടെത്തുകയും ചെയ്യുന്നു, അവ സൂചികയിലാക്കിയിട്ടില്ലെങ്കിൽ (അവയ്‌ക്കായി ഹാഷ്‌പാക്കേജ് സൃഷ്‌ടിച്ചിട്ടില്ല), അവ ഡൗൺലോഡ് ചെയ്യുകയും സൂചികയാക്കുകയും ചെയ്യുന്നു. ഫലം വളരെ നല്ല ഫലമാണ് - ഏറ്റവും പുതിയ പാക്കേജുകൾ ഉണ്ടെങ്കിലും, ഡെബിയൻ ഒഎസുകളെ ഹാഷ്‌ജെറ്റ് എല്ലായ്‌പ്പോഴും ഫലപ്രദമായി ഡ്യൂപ്ലിക്കേറ്റ് ചെയ്യും.

സൂചന ഫയലുകൾ

നിങ്ങളുടെ നെറ്റ്‌വർക്ക് നിങ്ങളുടെ ഉടമസ്ഥതയിലുള്ള ചില പാക്കേജുകളോ ഹാഷ്‌ജെറ്റ് ഹ്യൂറിസ്റ്റിക്‌സിൽ ഉൾപ്പെടുത്താത്ത ഒരു പൊതു പാക്കേജോ ഉപയോഗിക്കുന്നുവെങ്കിൽ, നിങ്ങൾക്ക് ഒരു ലളിതമായ hashget-hint.json സൂചന ഫയൽ ഇതിലേക്ക് ചേർക്കാം:

{
    "project": "wordpress.org",
    "url": "https://ru.wordpress.org/wordpress-5.1.1-ru_RU.zip"
}

അടുത്തതായി, ഓരോ തവണയും ഒരു ആർക്കൈവ് സൃഷ്‌ടിക്കുമ്പോൾ, പാക്കേജ് സൂചികയിലാക്കപ്പെടും (അത് മുമ്പ് ഉണ്ടായിരുന്നില്ലെങ്കിൽ), പാക്കേജ് ഫയലുകൾ ആർക്കൈവിൽ നിന്ന് ഡ്യൂപ്ലിക്കേറ്റ് ചെയ്യപ്പെടും. പ്രോഗ്രാമിംഗ് ആവശ്യമില്ല, വിമ്മിൽ നിന്ന് എല്ലാം ചെയ്യാനും എല്ലാ ബാക്കപ്പിലും സംരക്ഷിക്കാനും കഴിയും. ദയവായി ശ്രദ്ധിക്കുക, ഹാഷ് സം സമീപനത്തിന് നന്ദി, പാക്കേജിൽ നിന്നുള്ള ചില ഫയലുകൾ പ്രാദേശികമായി മാറ്റുകയാണെങ്കിൽ (ഉദാഹരണത്തിന്, ഒരു കോൺഫിഗറേഷൻ ഫയൽ മാറ്റി), തുടർന്ന് മാറ്റിയ ഫയലുകൾ ആർക്കൈവിൽ "ഉള്ളതുപോലെ" സംരക്ഷിക്കപ്പെടും, വെട്ടിച്ചുരുക്കപ്പെടില്ല.

നിങ്ങളുടെ സ്വന്തം പാക്കേജുകളിൽ ചിലത് ആനുകാലികമായി അപ്ഡേറ്റ് ചെയ്തിട്ടുണ്ടെങ്കിലും, മാറ്റങ്ങൾ വളരെ വലുതല്ലെങ്കിൽ, പ്രധാന പതിപ്പുകൾക്കായി മാത്രമേ നിങ്ങൾക്ക് സൂചന നൽകാനാകൂ. ഉദാഹരണത്തിന്, പതിപ്പ് 1.0-ൽ അവർ mypackage-1.0.tar.gz-ലേക്ക് ഒരു സൂചന നൽകി, അത് പൂർണ്ണമായും ഡീഡ്യൂപ്ലിക്കേറ്റ് ചെയ്യപ്പെടും, തുടർന്ന് അവർ പതിപ്പ് 1.1 പുറത്തിറക്കി, അത് അല്പം വ്യത്യസ്തമാണ്, പക്ഷേ സൂചന അപ്ഡേറ്റ് ചെയ്തില്ല. ഇത് ഒകെയാണ്. പതിപ്പ് 1.0-മായി പൊരുത്തപ്പെടുന്ന (പുനഃസ്ഥാപിക്കാൻ കഴിയുന്ന) ഫയലുകൾ മാത്രമേ ഡ്യൂപ്ലിക്കേറ്റ് ചെയ്തിട്ടുള്ളൂ.

ഹ്യൂറിസ്റ്റിക്സ് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിന്റെ ആന്തരിക സംവിധാനം മനസ്സിലാക്കുന്നതിനുള്ള ഒരു നല്ല ഉദാഹരണമാണ് സൂചന ഫയൽ പ്രോസസ്സ് ചെയ്യുന്ന ഹ്യൂറിസ്റ്റിക്. ഇത് hashget-hint.json ഫയലുകൾ (അല്ലെങ്കിൽ ഒരു ഡോട്ട് ഉള്ള .hashget-hint.json) മാത്രം പ്രോസസ്സ് ചെയ്യുകയും മറ്റെല്ലാം അവഗണിക്കുകയും ചെയ്യുന്നു. ഈ ഫയലിൽ നിന്ന്, ഏത് പാക്കേജ് URL ഇൻഡക്‌സ് ചെയ്യണമെന്ന് ഇത് നിർണ്ണയിക്കുന്നു, കൂടാതെ ഹാഷ്‌ജെറ്റ് അത് സൂചികയിലാക്കുന്നു (അത് ഇതിനകം അങ്ങനെ ചെയ്തിട്ടില്ലെങ്കിൽ)

ഹാഷ്സെർവർ

ബാക്കപ്പുകൾ സൃഷ്‌ടിക്കുമ്പോൾ പൂർണ്ണമായ ഇൻഡെക്‌സിംഗ് നടത്തുന്നത് തികച്ചും അധ്വാനമാണ്. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾ ഓരോ പാക്കേജും ഡൌൺലോഡ് ചെയ്യണം, അത് അൺപാക്ക് ചെയ്യുക, ഇൻഡെക്സ് ചെയ്യുക. അതിനാൽ ഹാഷ്‌ജെറ്റ് ഒരു സ്കീം ഉപയോഗിക്കുന്നു ഹാഷ്സെർവർ. ഇൻസ്റ്റാൾ ചെയ്ത ഡെബിയൻ പാക്കേജ് കണ്ടെത്തുമ്പോൾ, അത് പ്രാദേശിക ഹാഷ്പാക്കേജിൽ കാണുന്നില്ലെങ്കിൽ, ഹാഷ് സെർവറിൽ നിന്ന് ഹാഷ്പാക്കേജ് ഡൗൺലോഡ് ചെയ്യാൻ ആദ്യം ശ്രമിക്കും. ഇത് പ്രവർത്തിക്കുന്നില്ലെങ്കിൽ മാത്രം, ഹാഷ്‌ജെറ്റ് തന്നെ പാക്കേജ് ഡൗൺലോഡ് ചെയ്യുകയും ഹാഷ് ചെയ്യുകയും ചെയ്യുന്നു (അത് ഹാഷ്‌സെർവറിലേക്ക് അപ്‌ലോഡ് ചെയ്യുന്നു, അതിനാൽ ഭാവിയിൽ ഹാഷ്‌സെർവർ അത് നൽകുന്നു).

ഹാഷ്‌സെർവർ സ്കീമിന്റെ ഒരു ഓപ്‌ഷണൽ ഘടകമാണ്, അത് നിർണായകമല്ല, ഇത് റിപ്പോസിറ്ററികളിലെ ലോഡ് വേഗത്തിലാക്കാനും കുറയ്ക്കാനും മാത്രം സഹായിക്കുന്നു. എളുപ്പത്തിൽ പ്രവർത്തനരഹിതമാക്കാം (ഓപ്ഷണൽ --hashserver പാരാമീറ്ററുകൾ ഇല്ലാതെ). കൂടാതെ, നിങ്ങൾക്ക് എളുപ്പത്തിൽ കഴിയും നിങ്ങളുടെ സ്വന്തം ഹാഷ്സെർവർ ഉണ്ടാക്കുക.

ഇൻക്രിമെന്റൽ, ഡിഫറൻഷ്യൽ ബാക്കപ്പുകൾ, ആസൂത്രിതമായ കാലഹരണപ്പെടൽ

ഹാഷ്ഗെറ്റ് ഒരു ഡയഗ്രം നിർമ്മിക്കുന്നത് വളരെ എളുപ്പമാക്കുന്നു ഇൻക്രിമെന്റൽ, ഡിഫറൻഷ്യൽ ബാക്കപ്പുകൾ. എന്തുകൊണ്ട് നമ്മുടെ ബാക്കപ്പ് ഇൻഡെക്സ് ചെയ്തുകൂടാ (നമ്മുടെ എല്ലാ അദ്വിതീയ ഫയലുകൾക്കൊപ്പം)? ഒരു ടീം --submit നിങ്ങൾ പൂർത്തിയാക്കി! ഹാഷ്‌ജെറ്റ് സൃഷ്‌ടിക്കുന്ന അടുത്ത ബാക്കപ്പിൽ ഈ ആർക്കൈവിൽ നിന്നുള്ള ഫയലുകൾ ഉൾപ്പെടില്ല.

എന്നാൽ ഇത് വളരെ നല്ല സമീപനമല്ല, കാരണം പുനഃസ്ഥാപിക്കുമ്പോൾ മുഴുവൻ ചരിത്രത്തിലെയും എല്ലാ ഹാഷ്‌ജെറ്റ് ബാക്കപ്പുകളും പിൻവലിക്കേണ്ടിവരുമെന്ന് ഇത് മാറിയേക്കാം (ഓരോന്നിനും കുറഞ്ഞത് ഒരു അദ്വിതീയ ഫയലെങ്കിലും ഉണ്ടെങ്കിൽ). ഇതിനൊരു സംവിധാനമുണ്ട് ബാക്കപ്പുകളുടെ ആസൂത്രിതമായ കാലഹരണപ്പെടൽ. സൂചികയിലാക്കുമ്പോൾ, നിങ്ങൾക്ക് ഹാഷ്പാക്കേജിന്റെ കാലഹരണ തീയതി വ്യക്തമാക്കാൻ കഴിയും --expires 2019-06-01, ഈ തീയതിക്ക് ശേഷം (00:00 മുതൽ), ഇത് ഉപയോഗിക്കില്ല. ഈ തീയതിക്ക് ശേഷം ആർക്കൈവ് തന്നെ ഇല്ലാതാക്കാൻ കഴിയില്ല (എങ്കിലും ഹാഷ്‌ഗെറ്റിന് എല്ലാ ബാക്കപ്പുകളുടെയും URL-കൾ സൗകര്യപൂർവ്വം കാണിക്കാനാവും, അത് ഇപ്പോൾ അല്ലെങ്കിൽ ഏതെങ്കിലും തീയതിയിൽ ചീഞ്ഞഴുകിപ്പോകും).

ഉദാഹരണത്തിന്, ഞങ്ങൾ 1-ന് ഒരു പൂർണ്ണ ബാക്കപ്പ് ഉണ്ടാക്കുകയും മാസാവസാനം വരെയുള്ള ആയുഷ്കാലം സൂചികയിലാക്കുകയും ചെയ്താൽ, ഞങ്ങൾക്ക് ഒരു ഡിഫറൻഷ്യൽ ബാക്കപ്പ് സ്കീം ലഭിക്കും.

ഞങ്ങൾ പുതിയ ബാക്കപ്പുകൾ അതേ രീതിയിൽ സൂചികയിലാക്കിയാൽ, ഇൻക്രിമെന്റൽ ബാക്കപ്പുകളുടെ ഒരു സ്കീം ഉണ്ടാകും.

പരമ്പരാഗത സ്കീമുകളിൽ നിന്ന് വ്യത്യസ്തമായി, ഒന്നിലധികം അടിസ്ഥാന ഉറവിടങ്ങൾ ഉപയോഗിക്കാൻ ഹാഷ്‌ജെറ്റ് നിങ്ങളെ അനുവദിക്കുന്നു. മുമ്പത്തെ ബാക്കപ്പുകളിൽ നിന്നുള്ള ഫയലുകൾ കുറയ്ക്കുന്നതിലൂടെയും (എന്തെങ്കിലും ഉണ്ടെങ്കിൽ) പൊതു ഫയലുകൾ വഴിയും (ഡൗൺലോഡ് ചെയ്യാൻ കഴിയുന്നവ) ബാക്കപ്പ് കുറയ്ക്കും.

ചില കാരണങ്ങളാൽ ഡെബിയൻ വിഭവങ്ങളുടെ വിശ്വാസ്യത ഞങ്ങൾ വിശ്വസിക്കുന്നില്ലെങ്കിൽ (https://snapshot.debian.org/) അല്ലെങ്കിൽ മറ്റൊരു ഡിസ്ട്രിബ്യൂഷൻ ഉപയോഗിക്കുന്നു, നമുക്ക് എല്ലാ പാക്കേജുകളും ഉപയോഗിച്ച് ഒരിക്കൽ ഒരു പൂർണ്ണ ബാക്കപ്പ് ഉണ്ടാക്കാം, തുടർന്ന് അതിൽ ആശ്രയിക്കാം (ഹ്യൂറിസ്റ്റിക്സ് പ്രവർത്തനരഹിതമാക്കുന്നതിലൂടെ). ഇപ്പോൾ, ഞങ്ങളുടെ വിതരണങ്ങളുടെ എല്ലാ സെർവറുകളും ഞങ്ങൾക്ക് ലഭ്യമല്ലെങ്കിൽ (സോവനീർ ഇൻറർനെറ്റിലോ ഒരു സോംബി അപ്പോക്കലിപ്സിലോ), എന്നാൽ ഞങ്ങളുടെ ബാക്കപ്പുകൾ ക്രമത്തിലാണെങ്കിൽ, ഞങ്ങളുടെ മുമ്പത്തെ ബാക്കപ്പുകളെ മാത്രം ആശ്രയിക്കുന്ന ഏത് ചെറിയ ഡിഫ് ബാക്കപ്പിൽ നിന്നും നമുക്ക് വീണ്ടെടുക്കാനാകും. .

നിങ്ങളുടെ വിവേചനാധികാരത്തിൽ വിശ്വസനീയമായ വീണ്ടെടുക്കൽ ഉറവിടങ്ങളെ മാത്രമേ Hashget ആശ്രയിക്കുകയുള്ളൂ. നിങ്ങൾ വിശ്വസനീയമെന്ന് കരുതുന്നവ ഉപയോഗിക്കും.

ഫയൽപൂളും ഹിമാനിയും

യന്ത്രം ഫയൽപൂൾ പാക്കേജുകൾ ഡൗൺലോഡ് ചെയ്യുന്നതിന് ബാഹ്യ സെർവറുകളുമായി നിരന്തരം ബന്ധപ്പെടാതിരിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു, എന്നാൽ ഒരു പ്രാദേശിക ഡയറക്ടറിയിൽ നിന്നോ കോർപ്പറേറ്റ് സെർവറിൽ നിന്നോ പാക്കേജുകൾ ഉപയോഗിക്കുക, ഉദാഹരണത്തിന്:

$ hashget -u . --pool /tmp/pool

അഥവാ

$ hashget -u . --pool http://myhashdb.example.com/

ഒരു ലോക്കൽ ഡയറക്‌ടറിയിൽ ഒരു പൂൾ ഉണ്ടാക്കാൻ, നിങ്ങൾ ഒരു ഡയറക്‌ടറി സൃഷ്‌ടിച്ച് അതിലേക്ക് ഫയലുകൾ എറിയേണ്ടതുണ്ട്, ഹാഷുകൾ ഉപയോഗിച്ച് ഹാഷ്‌ജെറ്റ് തന്നെ അതിന് ആവശ്യമായത് കണ്ടെത്തും. HTTP വഴി പൂൾ ആക്സസ് ചെയ്യാൻ, നിങ്ങൾ ഒരു പ്രത്യേക രീതിയിൽ സിംലിങ്കുകൾ സൃഷ്ടിക്കേണ്ടതുണ്ട്; ഇത് ഒരു കമാൻഡ് ഉപയോഗിച്ചാണ് ചെയ്യുന്നത് (hashget-admin --build /var/www/html/hashdb/ --pool /tmp/pool). HTTP FilePool തന്നെ സ്റ്റാറ്റിക് ഫയലുകളാണ്, അതിനാൽ ഏത് ലളിതമായ വെബ് സെർവറിനും ഇത് സേവിക്കാൻ കഴിയും, സെർവറിലെ ലോഡ് ഏതാണ്ട് പൂജ്യമാണ്.

FilePool ന് നന്ദി, നിങ്ങൾക്ക് http(s) ഉറവിടങ്ങൾ മാത്രമല്ല അടിസ്ഥാന ഉറവിടങ്ങളായി ഉപയോഗിക്കാനാകും ഉദാഹരണത്തിന്,ആമസോൺ ഗ്ലേസിയർ.

ഹിമാനിയിലേക്ക് ബാക്കപ്പ് അപ്‌ലോഡ് ചെയ്‌ത ശേഷം, ഞങ്ങൾക്ക് അതിന്റെ അപ്‌ലോഡ് ഐഡി ലഭിക്കുകയും അത് ഒരു URL ആയി ഉപയോഗിക്കുകയും ചെയ്യുന്നു. ഉദാഹരണത്തിന്:

hashget --submit Glacier_Upload_ID --file /tmp/my-glacier-backup.tar.gz --project glacier --hashserver --expires 2019-09-01

ഇപ്പോൾ പുതിയ (ഡിഫറൻഷ്യൽ) ബാക്കപ്പുകൾ ഈ ബാക്കപ്പിനെ അടിസ്ഥാനമാക്കിയുള്ളതും ചെറുതായിരിക്കും. ഡിഫ്ബാക്കപ്പ് ടാർ അൺപാക്ക് ചെയ്തതിന് ശേഷം, അത് ഏത് ഉറവിടങ്ങളെയാണ് ആശ്രയിക്കുന്നതെന്ന് നമുക്ക് കാണാൻ കഴിയും:

hashget --info /tmp/unpacked/ list

ഈ ഫയലുകളെല്ലാം ഗ്ലേസിയറിൽ നിന്ന് പൂളിലേക്ക് ഡൗൺലോഡ് ചെയ്യാനും സാധാരണ വീണ്ടെടുക്കൽ പ്രവർത്തിപ്പിക്കാനും ഒരു ഷെൽ സ്‌ക്രിപ്റ്റ് ഉപയോഗിക്കുക: hashget -u /tmp/unpacked —pool /tmp/pool

കളി മെഴുകുതിരിക്ക് മൂല്യമുള്ളതാണോ?

ഏറ്റവും ലളിതമായ സാഹചര്യത്തിൽ, ബാക്കപ്പുകൾക്കായി നിങ്ങൾ കുറച്ച് പണം നൽകും (നിങ്ങൾ അവ ക്ലൗഡിൽ എവിടെയെങ്കിലും പണത്തിനായി സംഭരിച്ചാൽ). ഒരുപക്ഷേ വളരെ, വളരെ കുറവായിരിക്കാം.

എന്നാൽ അത് മാത്രമല്ല കാര്യം. അളവ് ഗുണമായി മാറുന്നു. നിങ്ങളുടെ ബാക്കപ്പ് സ്‌കീമിലേക്ക് ഉയർന്ന നിലവാരമുള്ള അപ്‌ഗ്രേഡ് ലഭിക്കാൻ നിങ്ങൾക്ക് ഇത് ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, ഞങ്ങളുടെ ബാക്കപ്പുകൾ ഇപ്പോൾ ചെറുതായതിനാൽ, പ്രതിമാസ ബാക്കപ്പുകളല്ല, ദിവസേനയുള്ള ബാക്കപ്പുകൾ ഉണ്ടാക്കാം. മുമ്പത്തെപ്പോലെ ആറുമാസത്തേക്കല്ല, 5 വർഷത്തേക്ക് അവ സംഭരിക്കുക. മുമ്പ്, നിങ്ങൾ ഇത് മന്ദഗതിയിലുള്ളതും എന്നാൽ വിലകുറഞ്ഞതുമായ "തണുത്ത" സ്റ്റോറേജിൽ (ഗ്ലേസിയർ) സംഭരിച്ചു, ഇപ്പോൾ നിങ്ങൾക്ക് അത് ഹോട്ട് സ്റ്റോറേജിൽ സൂക്ഷിക്കാം, അവിടെ നിന്ന് നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും വേഗത്തിൽ ഒരു ബാക്കപ്പ് ഡൗൺലോഡ് ചെയ്യാനും മിനിറ്റുകൾക്കുള്ളിൽ പുനഃസ്ഥാപിക്കാനും കഴിയും, ഒരു ദിവസത്തിലല്ല.

നിങ്ങൾക്ക് ബാക്കപ്പ് സംഭരണത്തിന്റെ വിശ്വാസ്യത വർദ്ധിപ്പിക്കാൻ കഴിയും. ഞങ്ങൾ അവ നിലവിൽ ഒരു സ്റ്റോറേജ് ഫെസിലിറ്റിയിൽ സംഭരിക്കുന്നുവെങ്കിൽ, ബാക്കപ്പുകളുടെ അളവ് കുറയ്ക്കുന്നതിലൂടെ, അവ 2-3 സ്റ്റോറേജ് സൗകര്യങ്ങളിൽ സംഭരിക്കാനും അവയിലൊന്ന് കേടായാൽ വേദനയില്ലാതെ അതിജീവിക്കാനും ഞങ്ങൾക്ക് കഴിയും.

എങ്ങനെ പരീക്ഷിച്ചു തുടങ്ങാം?

gitlab പേജിലേക്ക് പോകുക https://gitlab.com/yaroslaff/hashget, ഒരു കമാൻഡ് ഉപയോഗിച്ച് ഇൻസ്റ്റാൾ ചെയ്യുക (pip3 install hashget[plugins]) ദ്രുത-ആരംഭം വായിച്ച് നടപ്പിലാക്കുക. എല്ലാ ലളിതമായ കാര്യങ്ങളും ചെയ്യാൻ 10-15 മിനിറ്റ് എടുക്കുമെന്ന് ഞാൻ കരുതുന്നു. തുടർന്ന് നിങ്ങൾക്ക് നിങ്ങളുടെ വെർച്വൽ മെഷീനുകൾ കംപ്രസ് ചെയ്യാൻ ശ്രമിക്കാം, കംപ്രഷൻ ശക്തമാക്കാൻ ആവശ്യമെങ്കിൽ സൂചന ഫയലുകൾ ഉണ്ടാക്കാം, പൂളുകൾ, നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ ഒരു പ്രാദേശിക ഹാഷ് ഡാറ്റാബേസ്, ഒരു ഹാഷ് സെർവർ എന്നിവ ഉപയോഗിച്ച് കളിക്കാം, അടുത്ത ദിവസം ഇൻക്രിമെന്റൽ ബാക്കപ്പിന്റെ വലുപ്പം എന്താണെന്ന് നോക്കാം. ഇന്നലത്തേതിന് മുകളിലായിരിക്കും.

അവലംബം: www.habr.com