OpenVPN ലോഗുകൾ ആരുടേതാണ്: ഡീമണിന്റേതോ, rsyslog-ന്റേതോ, logrotate-ന്റേതോ?

ലോഗ് റോട്ടേഷൻ പ്രവചനാത്മകമായ രീതിയിൽ തകരുന്നു: മൂന്ന് ഘടകങ്ങൾ ഓരോന്നും ഫയൽ തങ്ങളുടേതാണെന്ന് കരുതുന്നു, ഫലം പുതിയത് ശൂന്യമായി നിൽക്കുമ്പോൾ വളർന്നുകൊണ്ടിരിക്കുന്ന ഒരു റോട്ടേറ്റ് ചെയ്ത ലോഗ് ആണ്. ഡീമൺ ഒരു ഡിസ്ക്രിപ്റ്റർ പിടിച്ചുവയ്ക്കുന്നു, logrotate വഴിയുടെ പേരു മാറ്റുന്നു, rsyslog തികച്ചും വേറൊരിടത്ത് എഴുതുന്നു. കൂമ്പാരത്തിൽ മറ്റൊരു നിയമം ചേർക്കുന്നതിന് മുൻപ് ഒരു എഴുത്തുകാരനെയും ഒരു റോട്ടേറ്ററെയും തിരഞ്ഞെടുക്കുക. താഴെയുള്ള പരിശോധനാപട്ടിക അതേ ക്രമത്തിൽ നീങ്ങുന്നു, കാരണം തുടർന്നുള്ള ഓരോ ഘട്ടവും അതിനെ ആശ്രയിച്ചിരിക്കുന്നു.

ഫയൽ ആരാണ് എഴുതുന്നതെന്ന് തീരുമാനിക്കുക

രണ്ട് രൂപകൽപ്പനകൾ സാധുവാണ്. ആദ്യത്തേതിൽ VPN പ്രക്രിയ തന്നെ സ്വന്തം log അല്ലെങ്കിൽ log-append ഓപ്ഷൻ വഴി ഫയൽ എഴുതുന്നു. രണ്ടാമത്തേതിൽ അത് റെക്കോർഡുകൾ സിസ്റ്റം ലോഗറിലേക്ക് അയക്കുന്നു, rsyslog അല്ലെങ്കിൽ journald അവ എവിടെ എത്തുന്നു എന്ന് തീരുമാനിക്കുന്നു.

ഇവ ബദലുകളാണ്, പാളികളല്ല. രണ്ടും സജീവമാക്കിയ ഹോസ്റ്റ് പരസ്പരം യോജിക്കാത്ത രണ്ട് ഫയലുകളുമായി അവസാനിക്കുന്നു, നിങ്ങൾ വായിക്കുന്നത് പലപ്പോഴും പഴയതാണ്. വഴി ബോധപൂർവം തിരഞ്ഞെടുക്കുക, പിന്നീട് മറ്റേ എഴുത്തുകാരനെ നീക്കം ചെയ്യുക.

എന്തെങ്കിലും മാറ്റുന്നതിന് മുൻപ് സേവനത്തിന്റെ പ്രാബല്യത്തിലുള്ള വിന്യാസം വായിക്കുക, unit ഫയലിനെ മറികടക്കാവുന്ന drop-in ഫയലുകൾ ഉൾപ്പെടെ. നിങ്ങൾ തിരുത്തിയ പ്രൊഫൈലിലുള്ള ഒരു നിർദ്ദേശം അതു തന്നെ പ്രവർത്തിക്കുന്ന പ്രക്രിയ ലോഡ് ചെയ്തതാണെന്ന് തെളിവല്ല. unit-നെ പ്രക്രിയയുടെ ആർഗ്യുമെന്റുകളുമായി, പിന്നീട് അത് യഥാർഥത്തിൽ തുറന്ന ഫയലുകളുമായി താരതമ്യം ചെയ്യുക.

ഫിൽട്ടർ ഇടുങ്ങിയതാകാൻ ഡീമണിന് പേരു നൽകുക

syslog വഴിയിൽ ഡീമണിന് പ്രത്യേക ഐഡന്റിറ്റി നൽകി അതിന്റെ മേൽ ഫിൽട്ടർ ചെയ്യുക. ഈ VPN ഇൻസ്റ്റൻസിന്റെ പ്രോഗ്രാം പേരുമായി യോജിക്കുന്ന നിയമം അതിന്റെ റെക്കോർഡുകളെ സൂക്ഷിപ്പ് നയം മറ്റൊന്നിനു സ്വന്തമായ ഒരു പങ്കിട്ട ഫയലിനു പുറത്ത് നിർത്തുന്നു.

ഇടുങ്ങിയ നിയമങ്ങൾ അടുത്ത ചോദ്യത്തിനും ഉത്തരം നൽകാൻ ഇടയാക്കുന്നു: ഈ വരി ഏത് സേവനമാണ് സൃഷ്ടിച്ചത്? VPN എന്ന വാക്കുള്ള എല്ലാത്തിനും യോജിക്കുന്ന ഫിൽട്ടർ രണ്ടാമത്തെ ടണലിന്റെ ട്രാഫിക്കും സന്തോഷത്തോടെ ശേഖരിച്ച് രണ്ടിനെയും മങ്ങലാക്കും. unit ലോഗറിന് നൽകുന്ന കൃത്യമായ ഐഡന്റിഫയറുമായി യോജിപ്പിക്കുക.

റെക്കോർഡുകൾ സ്വതവേയുള്ള ലക്ഷ്യത്തിലേക്കും വീഴാതിരിക്കാൻ പ്രവർത്തനത്തിന് ശേഷം നിയമം അടയ്ക്കുക. രണ്ട് ഫയലുകളിലും ആവർത്തിക്കുന്ന വരികൾ ലോഗിംഗ് ബഗ് പോലെ തോന്നുമെങ്കിലും യഥാർഥത്തിൽ വിട്ടുപോയ ഒരു നിർത്തലാണ്. ആ ഒറ്റ വിട്ടുപോകൽ സൂക്ഷിപ്പ് നയത്തിന്റെ ഡിസ്ക് ചെലവും ഇരട്ടിയാക്കുന്നു.

ഡിസ്ക്രിപ്റ്റർ നഷ്ടപ്പെടുത്താതെ റോട്ടേറ്റ് ചെയ്യുക

ഡീമൺ ഫയൽ എഴുതുമ്പോൾ logrotate വഴിയുടെ പേരു മാറ്റുന്നു, പക്ഷേ പ്രക്രിയ തന്റെ തുറന്ന ഡിസ്ക്രിപ്റ്റർ നിലനിർത്തുന്നു. എന്തെങ്കിലും പ്രക്രിയയെ യഥാർഥ വഴി വീണ്ടും തുറക്കാൻ നിർബന്ധിക്കുന്നതുവരെ പുതിയ റെക്കോർഡുകൾ പേരുമാറ്റിയ ഫയലിലേക്ക് തുടരുന്നു; അതുകൊണ്ടാണ് റോട്ടേഷൻ പ്രവർത്തിക്കുന്നതായി തോന്നുകയും പുതിയ ഫയൽ ശൂന്യമായി നിൽക്കുകയും ചെയ്യുന്നത്.

പരിഹാരം സേവനത്തിന്റെ രേഖപ്പെടുത്തിയ റീലോഡ് അല്ലെങ്കിൽ റീസ്റ്റാർട്ട് സ്വഭാവം പ്രവർത്തിപ്പിക്കുന്ന ഒരു postrotate പ്രവർത്തനമാണ്. ലോഗറിന് സിഗ്നൽ അയക്കുന്നത് തികച്ചും വേറൊരു പ്രവർത്തനമാണ്, സ്വന്തം ഫയൽ പിടിക്കുന്ന ഡീമണിന് അത് ഒന്നും ചെയ്യുന്നില്ല.

വീണ്ടും തുറക്കാൻ അസാധ്യമായിടത്ത് copytruncate ആണ് പകരം: ഫയൽ പകർത്തുക, പിന്നീട് അവിടെത്തന്നെ മുറിക്കുക. ഡിസ്ക്രിപ്റ്റർ സാധുവായി നിർത്തുന്നു, പക്ഷേ പകർപ്പിനും മുറിക്കലിനും ഇടയിൽ എഴുതിയതെല്ലാം നഷ്ടപ്പെടുന്നു, അതിനാൽ ഇത് പരിഹാരമല്ല, ഒരു കൈമാറ്റമാണ്. ലോഡിൽ ആ വിടവ് നിങ്ങൾ പിടിക്കാൻ ശ്രമിക്കുന്ന തകരാറിനെത്തന്നെ വിഴുങ്ങിയേക്കാം.

ഓരോ ഫയലിനും രണ്ടിൽ ഒന്ന് തിരഞ്ഞെടുത്ത് തിരഞ്ഞെടുപ്പ് എഴുതിവയ്ക്കുക, കാരണം ഒരേ വഴിയിൽ രണ്ടും കലർത്തിയാൽ പിന്നീട് ആരോപിക്കാൻ ഏറെ ബുദ്ധിമുട്ടുള്ള വിടവുകൾ ഉണ്ടാകും. ഒരേ ഡയറക്ടറിയിൽ രണ്ട് പാറ്റേണുകളും കാണുന്ന വായനക്കാരന് ഏതാണ് അധികാരമുള്ളതെന്ന് പറയാനാവില്ല.

സംഭവത്തിന്റെ ജാലകത്തിൽ നിന്ന് സൂക്ഷിപ്പ് നിശ്ചയിക്കുക

സൂക്ഷിപ്പും കംപ്രഷനും പരമാവധി വലിപ്പവും നിങ്ങൾ യഥാർഥത്തിൽ എത്ര പിന്നോട്ട് അന്വേഷിക്കുന്നു എന്നതിൽ നിന്ന് വരണം. കംപ്രഷനും വലിപ്പപരിധിയും ഉള്ള ഏഴ് ദിവസത്തെ ജാലകം പല വിന്യാസങ്ങൾക്കും ന്യായമായ തുടക്കമാണ്; ഒരു ട്യൂട്ടോറിയലിൽ നിന്ന് പകർത്തിയ സംഖ്യ അല്ല.

നയം ഒരിടത്ത് സൂക്ഷിക്കുക. logrotate ഫയൽ റോട്ടേറ്റ് ചെയ്യുകയും rsyslog അത് റോട്ടേറ്റ് ചെയ്യുകയും ചെയ്താൽ രണ്ടാമത്തെ റോട്ടേഷൻ ജയിക്കുന്നു, ആദ്യത്തേതിന്റെ നാമകരണ രീതി കുഴപ്പമായി അവശേഷിക്കുന്നു. ഉടമയെ തിരഞ്ഞെടുക്കുക, മറ്റേ റോട്ടേഷൻ ഓഫാക്കുക, ആ തീരുമാനം നയത്തിനരികിൽ കുറിക്കുക.

rsyslog-ന്റെ രേഖകൾ അതിന്റെ റൂട്ടിംഗ്, പ്രവർത്തന മാതൃക എന്നിവ ഉൾക്കൊള്ളുന്നു, ഡീമണിന്റെ സ്വന്തം ലോഗിംഗ് ഓപ്ഷനുകൾക്ക് OpenVPN സേവനത്തിന്റെ രേഖകൾ അധികാരമുള്ളതായി തുടരുന്നു. രണ്ടിൽ ഒന്നും നിങ്ങൾക്കുവേണ്ടി നിങ്ങളുടെ സൂക്ഷിപ്പ് നയം തീരുമാനിക്കുന്നില്ല.

ഒരു റോട്ടേഷനും ഒരു പുതിയ സംഭവവും പരിശോധിക്കുക

ഒരു റോട്ടേഷൻ മാത്രം നിർബന്ധമാക്കി പിന്നീട് ഒരു പുതിയ സംഭവം സൃഷ്ടിക്കുക, ഉദാഹരണത്തിന് പരാജയപ്പെട്ട പ്രാമാണീകരണം. പുതിയ റെക്കോർഡ് പുതിയ ഫയലിൽ പ്രത്യക്ഷപ്പെടുന്നുവെന്നും പഴയ ഫയൽ വളരുന്നത് നിർത്തിയെന്നും ഉറപ്പാക്കുക.

പുതിയ ഫയലിന്റെ അനുമതികളും പരിശോധിക്കുക, കാരണം മറ്റൊരു ഉടമയോടെ അത് വീണ്ടും സൃഷ്ടിക്കുന്ന റോട്ടേഷൻ അടുത്ത എഴുത്തിൽ എഴുത്തുകാരനെ തകർക്കുകയും ക്രാഷ് പോലെ തോന്നുന്ന വിടവ് ഉണ്ടാക്കുകയും ചെയ്യുന്നു. പോകുന്നതിന് മുൻപ് ഉടമയും മോഡും സേവന അക്കൗണ്ടുമായി താരതമ്യം ചെയ്യുക. തുടർന്ന് കംപ്രസ് ചെയ്ത ആർക്കൈവ് വായിക്കാനാകുന്നുവെന്ന് ഉറപ്പാക്കുക, കാരണം ആർക്കും തുറക്കാനാവാത്ത ആർക്കൈവ് സൂക്ഷിപ്പല്ല. പഴയ ഫയലിലെ ഏറ്റവും പുതിയ റെക്കോർഡ് വേഗം വായിക്കുന്നത് കംപ്രഷനും അനുമതികളും രണ്ടും തെളിയിക്കുന്നു.

ഓരോ ഘട്ടത്തിന്റെയും ഉടമ രേഖപ്പെടുത്തി അവസാനിപ്പിക്കുക: ഏത് ഘടകമാണ് എഴുതുന്നത്, ഏതാണ് റോട്ടേറ്റ് ചെയ്യുന്നത്, സൂക്ഷിപ്പ് നയം എവിടെയാണ്. ആ രേഖയാണ് അടുത്ത ലോഗിംഗ് സംഭവത്തെ ഏത് പാളി വരി വീഴ്ത്തി എന്ന് ഊഹിക്കാൻ ഒരു പകൽ മുഴുവൻ ചെലവഴിക്കുന്നതിനു പകരം അഞ്ച് മിനിറ്റ് പരിശോധനയാക്കി മാറ്റുന്നത്.