പ്രായോഗിക വെബ് അധിഷ്ഠിത ആഴത്തിലുള്ള പഠനവും ഉദാഹരണത്തിന്റെ സുരക്ഷയും മൂന്നാം പതിപ്പ് ഷാർലറ്റ് ഹാർപ്പർ ജൂലൈ 3, 2024 അപ്ഡേറ്റുചെയ്ത / 19 ജൂൺ 3, 2025

ഫോർവോർഡ്:

വെബിനായുള്ള സോഫ്റ്റ്വെയർ നിർമ്മിക്കുന്ന സോഫ്റ്റ്വെയർ നിർമ്മിക്കുന്ന സുരക്ഷാ പരിഗണനകൾ ഏതെങ്കിലും വെബ് ഡവലപ്പർയുടെ പദ്ധതിയുടെയും നിർമ്മാണത്തിന്റെയും ഒരു പ്രധാന ഭാഗമാണ്, അത് ആശ്രയിക്കാവുന്നതും സ്ഥിരതയുള്ളതും പ്രായോഗിക ആവശ്യങ്ങൾക്ക് ഉപയോഗപ്രദവുമാണ്. പിയേതൺ, സി / സി ++, പേജ്, സി / സി ++, ജാവ, ബാഷ് എന്നിവ നടപ്പിലാക്കാൻ ഡോം (പ്രമാണം സമയത്തെ കൊല്ലാൻ നോക്കുക അല്ലെങ്കിൽ ഇന്റർനെറ്റിൽ എന്തെങ്കിലും നേടുക, സാധാരണയായി ഒരു ടച്ച്സ്ക്രീൻ സ്മാർട്ട്ഫോൺ ഉപകരണത്തിൽ. ആദ്യം മുതൽ ഒരു വെബ്സൈറ്റ് നിർമ്മിക്കാൻ ആഗ്രഹിക്കുമ്പോൾ, പ്രത്യേകിച്ച് പണം നൽകാമെന്നത്, പ്രത്യേകിച്ച് പണം പാഴാക്കുന്നതിനായി, അത് ഉപയോഗിക്കാൻ സാധ്യതയുള്ള എന്തെങ്കിലും വികസിപ്പിക്കുന്നതിനും മിക്ക ആളുകൾക്കും അവശേഷിക്കുന്നതും, അത് ഉപയോഗത്തിന്റെ എളുപ്പത്തിൽ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്നു വഴക്കം. ഈ പുസ്തകത്തിലൂടെ വായിക്കാൻ നിങ്ങൾ കുറച്ച് മിനിറ്റ് ഉണ്ടെങ്കിൽ, നിങ്ങളുടെ ലക്ഷ്യങ്ങളെക്കുറിച്ച് എന്നോട് വ്യക്തിപരമായി സംസാരിക്കുകയും നിങ്ങളുടെ സ്വന്തം സോഫ്റ്റ്വെയറിനെക്കുറിച്ചും എന്തെങ്കിലും മാർഗ്ഗനിർദ്ദേശം നേടുകയും നിങ്ങളുടെ പ്രേക്ഷകരുടെ ആവശ്യങ്ങൾ നിറവേറ്റുകയും ചെയ്യുന്നു.

എന്നെക്കുറിച്ച്: സി / സി ++, ജാവ, പൈത്തൺ, HTML, HSS, JavaScript എന്നിവയിൽ ഞാൻ ഒരു സോഫ്റ്റ്വെയർ ഡെവലപ്പറാണ്. ആളുകൾ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്ന വെബ്സൈറ്റുകൾ, സന്ദർശിക്കാൻ ആഗ്രഹിക്കുന്നു, പഠിക്കാൻ ആഗ്രഹിക്കുന്നു, മാത്രമല്ല, പഠിക്കാനും പുന ate സൃഷ്ടിക്കുകയും കൊല്ലുകയും ചെയ്യും, ഏറ്റവും പ്രധാനമായി, ഞാൻ സോഫ്റ്റ്വെയർ വിൽക്കുന്നു. നിങ്ങൾ ഒരു വെബ്സൈറ്റ് കാണാനും പ്രവർത്തിക്കാനുമുള്ള ഒരു ആശയം നിങ്ങൾക്കായി ഒരു ആശയം ഉണ്ടെങ്കിൽ, ഞാൻ നിങ്ങളെ കണ്ടുമുട്ടുമ്പോൾ എന്റെ ആവശ്യങ്ങൾ നിറവേറ്റാൻ നിങ്ങൾ തയ്യാറാണ്, ഞാൻ നിങ്ങൾക്ക് ആക്സസ് ചെയ്യാൻ കഴിയും, നിങ്ങൾക്ക് മാത്രമേ പ്രവേശിക്കാൻ കഴിയൂ. എന്റെ സമയം വിൽക്കാൻ ശ്രമിക്കുന്നതിനുപകരം, ഞാൻ നിങ്ങളുടേത് വാങ്ങാൻ ശ്രമിക്കുകയാണ്: നിങ്ങൾ ആഗ്രഹിക്കുന്ന ഒരു സ്വതന്ത്ര സോഫ്റ്റ്വെയർ ഡെവലപ്പർ, നിങ്ങൾ ആഗ്രഹിക്കുന്ന ഒരു സ്വതന്ത്ര സോഫ്റ്റ്വെയർ ഡെവലപ്പർ, നിങ്ങൾ ആഗ്രഹിക്കുന്ന ഒരു വ്യക്തിഗത ജീവിതം നയിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. ഞാൻ വ്യക്തമായിരിക്കട്ടെ, ഞാൻ നിങ്ങൾക്ക് നൽകുന്ന വിദ്യാഭ്യാസം അന mal പചാരികമാകും. നിങ്ങൾക്ക് സ്കൂളിൽ പോയി ഇതെല്ലാം ഒരു formal പചാരിക വിദ്യാഭ്യാസം ഉപയോഗിച്ച് പഠിക്കാം, അല്ലെങ്കിൽ സ്കൂളിൽ ഈ പുസ്തകം വായിക്കുക, നിങ്ങളുടെ അസൈൻമെന്റുകൾ പൂർത്തിയാക്കി, ഞാൻ നിങ്ങളെ ചൂടുള്ള സീറ്റിൽ നിന്ന് എടുത്തുകളയുക, പക്ഷേ ഞാൻ നിങ്ങളെ ly ദ്യോഗിക സീറ്റിൽ നിന്ന് മാറ്റിസ്ഥാപിക്കുകയും നിങ്ങളോട് നിയമനങ്ങൾ പൂർത്തിയാക്കാൻ ആവശ്യപ്പെടുകയും ചെയ്യില്ല. ഞാൻ നിങ്ങളുടെ പ്രൊഫസറല്ല, നിങ്ങളുടെ സ്വന്തം വിജയത്താൽ നയിക്കപ്പെടുന്ന ഒരു കരിയറിലേക്ക് നിങ്ങളെ നയിക്കാൻ ആഗ്രഹിക്കുന്ന ഒരു സുഹൃത്തിനെപ്പോലെ നിങ്ങൾക്ക് എന്നെക്കുറിച്ച് ചിന്തിക്കാൻ കഴിയും. ഞാൻ നിങ്ങളെ വിജയിപ്പിക്കുന്നില്ല, നിങ്ങളുടെ സമയത്തിനൊപ്പം നിങ്ങൾ അത് വാങ്ങേണ്ടതുണ്ട്. കോഡ് ചെയ്യാൻ പഠിക്കുന്നത് കുത്തനെയുള്ള ഒരു പഠന വക്രമുണ്ട്, മാത്രമല്ല ഒരിക്കലും എളുപ്പമായിരുന്നില്ല, അല്ലെങ്കിൽ ആയിരിക്കണം. നിങ്ങൾ സാധ്യമാകുന്നത് നിങ്ങൾക്ക് ബുദ്ധിമുട്ടായി പ്രവർത്തിക്കുകയും പരീക്ഷിക്കുകയും പരാജയപ്പെടുകയും ചെയ്യുമ്പോൾ, നിങ്ങൾ നിരാശപ്പെടുത്തുന്നതിനും ആപ്ലിക്കേഷനുകൾ സ്വയം സൃഷ്ടിക്കുന്നതിനും നിങ്ങൾ നിരാശപ്പെടുത്താനും നിങ്ങൾ നിരാശരാകുമെന്നും തുടരാനും ആവശ്യമാണ്. അത് കോഡിന്റെ സ്വഭാവത്തിലാണ്. പ്രോഗ്രാമർ പിശക് സന്ദേശങ്ങൾ നൽകുന്നതിന് രൂപകൽപ്പന ചെയ്ത ഒരു കംപൈലർ ആണ് കോഡ് പ്രവർത്തിപ്പിക്കുന്നത്, നിങ്ങൾ നിങ്ങളുടെ തിരയൽ എഞ്ചിനിൽ പിശക് എങ്ങനെ കോഡ് ചെയ്യാണെന്നും മറ്റ് ആളുകളുടെ ഉദാഹരണങ്ങൾ വായിക്കുമെന്നും ഇവ നിങ്ങളെ പഠിപ്പിക്കും. ഞാൻ പറയണം, ഒരു അപ്ലിക്കേഷൻ നിർമ്മിക്കുന്നതിന് നിങ്ങൾ അങ്ങേയറ്റം സമ്പന്നവും മിടുക്കവും വിജയകരമോ അല്ലെങ്കിൽ വിശദമായതോ ആയ അല്ലെങ്കിൽ വിശദമായ അല്ലെങ്കിൽ ഡിഗ്രൈഡ് ചെയ്യേണ്ടതില്ല. നിങ്ങൾക്കായി കമ്പ്യൂട്ടർ നിങ്ങൾക്കായി പരിപാലിക്കുന്നു. നിങ്ങൾ പരീക്ഷിക്കുന്നതിലൂടെയും ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നതിലൂടെയും ശ്രദ്ധ കേന്ദ്രീകരിക്കുകയും നിങ്ങൾ ചെയ്യുന്നതിൽ ശ്രദ്ധേയമാക്കുകയും ചെയ്യേണ്ടതുണ്ട്, നിങ്ങൾ ചെയ്യുന്നതിന്റെ പൂർണമായും വിജയകരമായ ഒരു കരിയർ നിങ്ങൾക്കുണ്ടാകും.

ഞാൻ ആരാണ്: അവസാന ഭാഗം പഠനത്തെക്കുറിച്ച് കൂടുതലാണെന്നും ഈ പുസ്തകത്തിൽ നിന്ന് നിങ്ങളുടെ വഴികൾ എടുക്കുന്നുവെന്നും ഞാൻ മനസ്സിലാക്കുന്നു. ഞാൻ ആരാണ് കൃത്യമായി? അത് സങ്കീർണ്ണമായ ചോദ്യമാണ്. ഞാൻ അത് ഞാൻ പലവിധത്തിൽ വ്യക്തതയുമുള്ള ഒരു മെഡിക്കൽ അവസ്ഥയിൽ നിന്ന് ഞാൻ അനുഭവിക്കുന്നു, അതേസമയം, എന്നെത്തന്നെ പരിചയപ്പെടുത്തുമ്പോൾ എന്റെ ജീവിതത്തെ കൂടുതൽ ബുദ്ധിമുട്ടാക്കുന്നു. ചുരുക്കത്തിൽ, നിങ്ങൾ ഈ പുസ്തകം വായിക്കുകയാണെങ്കിൽ, നിങ്ങൾ അതിലൂടെ അതിലേക്ക് കൊണ്ടുവന്ന് അത് ഉപയോഗപ്രദമാണെന്ന് കരുതി, അല്ലെങ്കിൽ നിങ്ങൾ ഇത് ഉപയോഗപ്രദമാണെന്ന് കരുതി, നിങ്ങൾ ചെയ്യുന്ന എല്ലാ കാര്യങ്ങളിലും നിങ്ങൾ വിജയിക്കാൻ ആഗ്രഹിക്കുന്നതുപോലെ ഞാൻ നിങ്ങളാണ്. ഞാൻ ഒരു എഞ്ചിനീയറാണ്, ഒരു സോഫ്റ്റ്വെയർ ഡെവലപ്പർ, ഒരു വിദ്യാർത്ഥി, ഒപ്പം, അത് ഒരു വലിയ പസിൽ, അവശേഷിക്കുന്ന മറ്റ് വിദ്യാർത്ഥികൾക്കും ഞാൻ ഈ പുസ്തകം എഴുതുന്നു, അത് അവരുടെ ജീവിതം സുഗമമാക്കാൻ ആഗ്രഹിക്കുന്നു, അത് വിജയം നയിക്കാൻ കഴിയും, അത് വിജയം നയിക്കാൻ കഴിയും. പ്രധാനമായും, ഇതാണ് ഞാൻ ചെയ്യുന്നത്: എന്നെത്തന്നെ സഹായിക്കാൻ ഞാൻ അപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നു. ഞാൻ ഒരു രചയിതാവാണ്, എന്റെ പോര്ട്ട്ഫോളിയൊ ഒരുമിച്ച് ഒരു ഉപയോഗപ്രദമായ ഒരു പ്രമാണമായി ചേർക്കുന്നതിന് ഞാൻ ഉദ്ദേശിക്കുന്ന എന്റെ ആദ്യ പ്രസിദ്ധീകരണമാണിത്, ഞാൻ ഒരു കലാകാരനാണ്. ഞാൻ നിങ്ങളോട് ഇത് നിങ്ങളോട് പ്രവേശിക്കും, ഞാൻ ഒരു വിചിത്ര വ്യക്തിയുടെ അടുത്താണ്. ഞാൻ തികഞ്ഞവനല്ല, കൂടുതൽ വിജയത്തോടെ എനിക്ക് കോളേജുകളും സർവകലാശാലയും ഉപേക്ഷിക്കാൻ കോളേജുകളും സർവകലാശാലയും ഉപേക്ഷിക്കാൻ ശ്രമിക്കുന്നതിനാൽ എനിക്ക് നിയമത്തോടൊപ്പം പ്രവർത്തിച്ചിട്ടുണ്ട്. ഞാൻ ജനിച്ച ഒരു സ്ത്രീയാണ്, ഞാൻ മേക്കപ്പ് ധരിക്കുന്നു, എന്നെത്തന്നെ എടുക്കുന്നു, വസ്ത്രങ്ങളും മറ്റ് സ്ത്രീകളും ധരിക്കുക, സ്വഭാവമനുസരിച്ച് ഒരു വയസ്സായി ഞാൻ സ്വയം ബോധവാന്മാരായി തുടരുന്നു. മുൻകാലങ്ങളിൽ ഞാൻ മറ്റ് ആളുകളുമായി പ്രശ്നങ്ങളുണ്ടായിരുന്നു, അത് എഴുത്തും കെട്ടിട നിർമ്മാണവുമായി മുന്നേറുന്നു, നിങ്ങളുടെ കൈകളിൽ ഈ പുസ്തകം ലഭിക്കാൻ എനിക്ക് കഴിഞ്ഞില്ലെന്ന് ഞാൻ ക്ഷമ ചോദിക്കുന്നു: നിങ്ങൾക്ക് ഇത് ആവശ്യമാണ്. എന്റേത് പോലെ കാണപ്പെടുന്ന കോഡ് വായിച്ച് അത് എഴുതുകയും എഴുതുകയും ചെയ്യാനും നിങ്ങൾ ആഗ്രഹിക്കുന്നു, മാത്രമല്ല ഇത് നിങ്ങളുടെ കീബോർഡ് മാപ്പിംഗ് ചെയ്യുന്നതിന് പകരം, നിങ്ങളുടെ ജീവിതത്തിൽ വിജയിക്കേണ്ട വിഭവങ്ങൾ നിങ്ങൾക്കുണ്ട്. വളർന്നുവരുന്ന, ആരോഗ്യസ്ഥിതികൾ, ആരോഗ്യം അവസ്ഥകൾ, ഡോക്ടർമാർ, മാധ്യമങ്ങൾ, നിയമം എന്നിവയും എനിക്ക് എല്ലാത്തരം പ്രശ്നങ്ങളും ഉണ്ടായിരുന്നു, എന്റെ കോഡ് ഫെമിനിസവും പെൺ സ്വഭാവവും വിഭജിത, നിരാശനായ ലോകത്ത് അശ്ലീലമാക്കുന്നു. എന്നിരുന്നാലും, ഈ പുസ്തകം, എന്റെ കുഞ്ഞേ, എന്റെ കുഞ്ഞേ, എന്റെ പോർട്ട്ഫോളിയോ, എന്റെ ഉപജീവനമാർഗം, അതിനാൽ നിങ്ങൾ വാചകം വീട്ടിൽ എടുക്കുമ്പോൾ ഞാൻ നിങ്ങളുടെ പരിഗണനയെ അഭിനന്ദിക്കുന്നു. ദയവായി ഞാൻ തികഞ്ഞവനല്ല, ഈ പുസ്തകത്തിൽ പിശകുകളും പുനരവലോകനങ്ങളും പുതിയ പതിപ്പുകളും ഉണ്ടാകും, എന്റെ എഴുത്ത് വിജയകരമായ അനുഭവം നേടുന്നതിന് നിങ്ങളുടെ ലോജിക്കൽ തലച്ചോറിനെ നിങ്ങൾക്ക് നന്നായി ചിന്തിക്കേണ്ടതുണ്ട്. കൂടാതെ, നിങ്ങൾ എഴുതുമ്പോൾ വെല്ലുവിളികൾ നേരിടുമ്പോഴും ഞാൻ നിങ്ങൾക്ക് നന്നായി ഉദ്ദേശിക്കുന്നുവെന്ന് മനസ്സിലാക്കുക. ഇതുപോലൊന്ന് ചിന്തിക്കുക: നിങ്ങൾ ഡിജിറ്റൽ സ്പെയ്സിൽ ഒരു കമ്പ്യൂട്ടർ സിസ്റ്റം വാടകയ്ക്കെടുക്കാൻ കഴിയുമ്പോൾ, നിങ്ങൾ കണ്ടുമുട്ടാന് ​​കഴിയുന്ന എന്തും ചെയ്യാൻ നിങ്ങൾക്ക് ഒരു കമ്പ്യൂട്ടർ സിസ്റ്റം വാടകയ്ക്കെടുക്കാൻ, നിങ്ങൾ കണ്ടുമുട്ടുന്ന എല്ലാ വിവരങ്ങളും സംഭരിക്കുക, നിങ്ങൾ കഴിക്കുന്ന വിവരങ്ങളുള്ളതും പ്രസിദ്ധീകരിക്കുന്നതുമായ ബുദ്ധിമുട്ടുകൾ നിങ്ങൾ നേരിടും നേരിടുന്നു. ഒരേ ബുദ്ധിമുട്ടുകൾ നേരിടുന്നതിനാൽ ഞാൻ ഇത് നിങ്ങളോട് പറയുന്നു. നിങ്ങളുടെ സ്വന്തം അപകടസാധ്യതയിൽ ഈ പുസ്തകം ഉപയോഗിക്കുക, സുരക്ഷിതമായ ഒരു ക്രമീകരണത്തിനുള്ളിൽ സോഫ്റ്റ്വെയർ നിർമ്മിക്കുന്നതിന് നിങ്ങൾക്ക് ലഭ്യമായതോ തെറ്റായ രീതിയിൽ, ഞാൻ നിങ്ങൾക്ക് ഈ വാചകം കൊണ്ടുവരുമ്പോൾ, ഞാൻ നിങ്ങളെ ഏത് മാന്യൻ. ജോലി, ഇന്റർനെറ്റ്. കുറച്ച് വാക്കുകളിലൂടെ ഞാൻ ആരാണെന്ന് നിങ്ങൾക്ക് വളരെ പരിചിതമായിരിക്കില്ല, പക്ഷേ നിങ്ങളുടെ ജോലി പൂർത്തിയാക്കാൻ നിങ്ങളുടെ സ്വന്തം പ്രോജക്ടുകൾ നിർമ്മിക്കുമ്പോൾ നിങ്ങൾ എന്നെ മനസിലാക്കുന്നതിനനുസരിച്ച് നിങ്ങൾ എന്നെ മനസ്സിലാക്കും. നിങ്ങളുടെ പ്രൊഫസർമാർക്കോ അധ്യാപകർക്കോ നിങ്ങൾ എന്തെങ്കിലും നിയോഗിച്ചിട്ടില്ലാത്തതിനാൽ, നിങ്ങൾ വായിച്ചതുപോലെ സ്വയം ഒരു പോര്ട്ട്ഫോളിയോ നിർമ്മിക്കാൻ ഞാൻ നിങ്ങളെ പ്രോത്സാഹിപ്പിക്കുന്നു, പക്ഷേ നിങ്ങൾ വായിച്ചതിന്റെ ഒരു പോര്ട്ട്ഫോളിയോ നിർമ്മിക്കാൻ ഞാൻ നിങ്ങളെ വളരെയധികം പ്രോത്സാഹിപ്പിക്കും. എന്റെ മുമ്പത്തെ പ്രോജക്റ്റുകളിൽ നിന്ന് കോഡ് ഉൾപ്പെടുത്തുന്നതിനാൽ, ഒരു ലളിതമായ അപ്ലിക്കേഷൻ പോലെ, ഒരു ലളിതമായ അപ്ലിക്കേഷൻ പോലെ, ഒരു ലളിതമായ ആപ്ലിക്കേഷൻ പോലെ, ഞാൻ സൃഷ്ടിച്ച ഒരു ലളിതമായ ആപ്ലിക്കേഷൻ, ഒപ്പം പഠിക്കാൻ പഠിച്ചതും എന്റെ ക്യാപ്സ്റ്റോൺ പ്രോജക്റ്റും, കൂടാതെ, നിങ്ങളുടെ സുഹൃത്തിനോടോ കുടുംബത്തിലോ, നിങ്ങൾക്കോ ​​അല്ലെങ്കിൽ കുടുംബം, അല്ലെങ്കിൽ വാർത്ത എന്നിവയിൽ നിങ്ങൾ കണ്ടെത്തിയേക്കാം.

ഈ പുസ്തകം എന്താണ്: ഉദാഹരണത്തിലൂടെ ഈ പുസ്തകം ഒരു ട്യൂട്ടോറിയലാണ്. നിങ്ങൾക്ക് ഇവിടെ കോഡ് കണ്ടെത്താം, നിങ്ങൾ എങ്ങനെ കോഡ് ചെയ്യാൻ പഠിപ്പിക്കാമെന്ന നിർദ്ദേശങ്ങൾ, ഒപ്പം നിങ്ങളുടെ കോഡ് എങ്ങനെ ശരിയാക്കാമെന്നും, നിങ്ങളുടെ കോഡ് എങ്ങനെ സംരക്ഷിക്കാമെന്നും, നിങ്ങളുടെ കോഡ് എങ്ങനെ പരിമിതപ്പെടുത്തുകയും ചെയ്യുന്നു, ഒപ്പം നിങ്ങളുടെ അപ്ലിക്കേഷനും കമ്പനിയും എങ്ങനെ അവതരിപ്പിക്കുന്നു, ഒപ്പം നിങ്ങളുടെ അന്തിമ ഉപയോക്താക്കൾക്ക് കഴിയുന്നത്ര ആകർഷകമാകാൻ നിങ്ങൾ നിർമ്മിക്കുന്ന സോഫ്റ്റ്വെയർ നിങ്ങളുടെ വെബ്സൈറ്റിന്റെ സന്ദർശകർക്ക് കഴിയുന്നത്ര ആകർഷകമാണ്. ഈ പുസ്തകത്തിൽ, ഒരു പ്ലാറ്റ്ഫോമിലും സുരക്ഷയിലും വെബിൽ ശ്രദ്ധ കേന്ദ്രീകരിച്ച് ഞാൻ സോഫ്റ്റ്വെയർ രൂപകൽപ്പനയുടെ നിരവധി ഉദാഹരണങ്ങൾ പ്രകടിപ്പിക്കും. ബാക്കപ്പും സ്ക്രിപ്റ്റിംഗ് സവിശേഷതകളുമുള്ള യുണിക്സ് ഷെൽ ഉപയോഗിച്ച് ഒരു അടിസ്ഥാന പ്രോജക്റ്റ് നിർമ്മിച്ച് ഞങ്ങൾ പഠന അനുഭവം ആരംഭിക്കും. തുടർന്ന്, ഞങ്ങൾ ഒരു അടിസ്ഥാന ബ്ലോഗ് വെബ്സൈറ്റ് പരിശോധിക്കുകയും ഫോട്ടോ, വീഡിയോ സവിശേഷതകൾ ഉപയോഗിച്ച് ഞങ്ങളുടെ ബ്ലോഗ് അപ്ഗ്രേഡുചെയ്യുകയും സ software ജന്യ സോഫ്റ്റ്വെയർ ഉപയോഗിച്ച് സുരക്ഷാ പരിഹാരങ്ങൾ നടത്താനും ഞങ്ങളുടെ സെർവർ സുരക്ഷിതമാക്കാനും ഒരു പ്ലഗ് ആസ്റ്റേറ്റ് പ്രാമാണീകരണ മൊഡ്യൂൾ (pam) ഉപയോഗിച്ച് ഈ സവിശേഷതകൾ ഉപയോഗിക്കുക. തുടർന്ന് ഫയൽ കൈകാര്യം ചെയ്യൽ, പ്രോസസ്സിംഗ്, വീഡിയോ എഡിറ്റിംഗ്, വോയ്സ് സംഭാവന, ബാർകോഡ് സ്കാനിംഗ്, ഒപ്റ്റിക്കൽ പ്രതീക തിരിച്ചറിയൽ എന്നിവ ഞങ്ങൾ അവലോകനം ചെയ്യും. സ and ജന്യവും പണമടച്ചുള്ളതുമായ ഓപ്ഷനുകൾ ഉപയോഗിച്ച് ഞങ്ങളുടെ സോഫ്റ്റ്വെയറിനെ കൂടുതൽ ഉപയോഗപ്രദവും സുരക്ഷിതവുമാക്കാൻ സഹായിക്കുന്ന API- കൾ ഞങ്ങൾ പരിശോധിക്കും. വഴിയിൽ, ബാരൽ, റിപ്പന്റ് ഡിസൈൻ, ടർററ്റ്, ഡ്രോൺ ഡിസൈൻ, ടർററ്റ്, ഡ്രോൺ ഡിസൈൻ, എന്നിവ ഉൾപ്പെടെയുള്ള ശാരീരിക സുരക്ഷ, മറ്റ് പ്രിൻസിപ്പൽമാർ എന്നിവ ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും. ഗെയിമുകൾ, 2 ഡി, 3 ഡി റെൻഡറിംഗ് എഞ്ചിനുകൾ എന്നിവ പണിയാനും അടിസ്ഥാനപരമായ അളവിലുള്ള ഹാർഡ്വെയർ ഉപയോഗിച്ച് ഞങ്ങൾ ഇടവേളകൾ എടുക്കും, അടിസ്ഥാനപരമായ ഡൈനിഷൻ റെൻഡറിംഗ് സോഫ്റ്റ്വെയറിന്റെ ഉദാഹരണങ്ങളും സിലിക്കൺ റബ്ബറിലെ ഒരു ഇലക്ട്രോണിക് വൈബ്രറ്റിംഗ് മസാജറും. ഞങ്ങളുടെ സോഫ്റ്റ്വെയർ നന്നായി സുരക്ഷിതമാക്കുന്നതിന് ഞങ്ങൾ ഇതിനകം ലഭ്യമായ മെഷീൻ പഠന പരിഹാരങ്ങൾ ഉപയോഗിക്കും. പ്രക്രിയ കാര്യക്ഷമമാക്കുന്നതിനും സുരക്ഷിതമാക്കുന്നതിനുമായി വെബിന് ലഭ്യമായ സ്റ്റോക്ക് ഉപകരണങ്ങളും ഞങ്ങൾ ഉപയോഗിക്കും. ഒരു വെബ് ആപ്ലിക്കേഷൻ നിർമ്മിക്കുന്നതിലും കമ്പ്യൂട്ടറിന്റെയും ഉൾച്ചേർത്ത മെക്കാനിക്കൽ സിസ്റ്റങ്ങളുടെയും ഒരു പ്രൊഫഷണൽ ശൃംഖലയുമായി ഈ പുസ്തകം ഒരു വഴികാട്ടിയാണ്, കൂടാതെ സോഫ്റ്റ്വെയറിന്റെയും ഉൾച്ചേർത്ത മെക്കാനിക്കൽ സിസ്റ്റങ്ങളുമായി സംയോജിപ്പിക്കുന്നതിനും പശ്ചാത്തലക്കാരാരോ അല്ലെങ്കിൽ മുൻ അനുഭവം ഉണ്ടാക്കുന്നതിനുമുള്ള ഒരു ഗൈഡ് മൊത്തത്തിൽ.

ഈ പുസ്തകം ഇല്ലാത്തത്: നിങ്ങൾക്ക് ഒരു വെബ്സൈറ്റ് വേണമെങ്കിൽ, നിങ്ങൾക്ക് ഒരു ലളിതമായ സ്റ്റോർ സജ്ജമാക്കി നിങ്ങൾക്ക് ആവശ്യമുള്ളത് വിൽക്കാനും വിൽക്കാനും കഴിയും, ഒരു ബ്ലോഗ് പോസ്റ്റുചെയ്യുക, അല്ലെങ്കിൽ വീഡിയോകൾ പോസ്റ്റുചെയ്യുക, അല്ലെങ്കിൽ ഒരു കോഡ് എഴുതുക. ഈ പുസ്തകം അങ്ങനെയല്ല. നിങ്ങൾക്ക് ഇതിനകം കണ്ടെത്താനാകുന്ന ഏത് സോഫ്റ്റ്വെയറുകളേക്കാളും കൂടുതൽ ഉപയോഗപ്രദമായ, പൂർണ്ണമായ സവിശേഷതകൾ, തുടങ്ങിയവ, കാരണം ഇത് കൂടുതൽ ഉപയോഗപ്രദമാണ്, അത് ഇപ്പോഴും പ്രോട്ടോടൈപ്പുകളിൽ പ്രവർത്തിക്കുന്നത് ചെലവേറിയതാണെന്ന് ഈ പുസ്തകം നിങ്ങളെ പഠിപ്പിക്കും, മാത്രമല്ല, ഒരു പഴയ പഴയ കമ്പനികൾ പ്രവർത്തിപ്പിക്കുന്നത്, ബാക്ക്അപ്പ്, ബോധ്യപ്പെടുത്തേണ്ട കമ്പനികൾ, ശരിക്കും ഒന്നും ചെയ്യാത്തവരുമായി സജ്ജീകരിച്ചിരിക്കുന്നു. നിങ്ങൾ ഈ പുസ്തകം സൂക്ഷ്മമായി പിന്തുടരുകയാണെങ്കിൽ, നിങ്ങൾ കോഡ്, റിസർച്ച് കോഡ്, നിങ്ങളുടെ സ്വന്തം അപ്ലിക്കേഷനുകൾ നിർമ്മിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു, നിങ്ങൾ ചെയ്യുന്നതിൽ നിന്ന് നിങ്ങൾ പണം സമ്പാദിക്കും. ആദ്യഘട്ടത്തിൽ പോലും ഞാൻ ഈ പുസ്തകത്തിൽ നിന്ന് പണം സമ്പാദിക്കും, കാരണം അതിൽ വിവരങ്ങൾ അടങ്ങിയിട്ടുണ്ട്, കാരണം ഇതിൽ അടങ്ങിയിരിക്കുന്ന വിവരങ്ങളും വായിക്കാൻ താൽപ്പര്യമുണ്ടെന്നും അവർ വാങ്ങുമ്പോഴോ എന്റെ അപ്ലിക്കേഷനുകൾ ഉപയോഗിക്കുമ്പോഴോ വാങ്ങുകയും ചെയ്യുന്നു. ഈ പുസ്തകം നിങ്ങൾക്കായി ഒരു അപ്ലിക്കേഷൻ നിർമ്മിക്കില്ല, മാത്രമല്ല ഇത് നിങ്ങൾക്ക് ശരിയായ ദിശയിൽ ചൂണ്ടിക്കാണിക്കുകയും നിങ്ങൾ ആവശ്യമുള്ള ഉപകരണങ്ങൾ, നിങ്ങൾ ഏത്.

നിങ്ങൾ എന്താണ് പഠിക്കുന്നത്: സോഫ്റ്റ്വെയർ എങ്ങനെ നിർമ്മിക്കാമെന്നും വിൽക്കാമെന്നും ഇത് എങ്ങനെ നിർമ്മിക്കാമെന്നും വിൽക്കാമെന്നും, ഫാലിഷ്യൽ തിരിച്ചറിയൽ, റീഡിംഗ് സോൺ ബാർകോഡ് സ്കാനിംഗ്, വെബ് എപിഐകൾ, ബ്ലൂടൂത്ത്, റെൻഡർ ചെയ്യാൻ വെബ് എപിഐകൾ എന്നിവ, വെബ് എപിഐകൾ (എൻഎഫ്സി) ആശയവിനിമയം തുടങ്ങിയ സന്ദേശങ്ങൾ (എൻഎഫ്സി) ആശയവിനിമയം നടത്താൻ ഈ പുസ്തകം നിങ്ങളെ പഠിപ്പിക്കും. ഒരു നെറ്റ്വർക്ക് ചെയ്ത കമ്പ്യൂട്ടർ എങ്ങനെ ഉപയോഗിക്കാമെന്ന് ഈ പുസ്തകം നിങ്ങളെ പഠിപ്പിക്കും, നിങ്ങളുടെ സോഫ്റ്റ്വെയർ സ്ഥാപിക്കുന്നതിനും ബാഷ് ചെയ്യുന്നതും ഒരു ബാഷ് കോഡ് നിർമ്മിക്കുന്നതെങ്ങനെ, സ്ഥിരീകരണത്തിനായി ടെക്സ്റ്റ് സന്ദേശങ്ങൾ പോലുള്ള സുരക്ഷാ സവിശേഷതകൾ ഉപയോഗിച്ച് ഉപയോക്തൃ ലോഗുകളും ഇന്റഡക്ടറും എങ്ങനെ പ്രവർത്തനക്ഷമമാക്കുക അല്ലെങ്കിൽ മറ്റ് ആവശ്യങ്ങൾ, ഐഡി സ്കാനിംഗ്, ഇമേജ്, വീഡിയോ മോഡറേഷൻ, ഡാറ്റ മൈക്രോട്രോൻസ്ഫർട്ടൻസ്, പേയ്മെന്റ് പ്രോസസ്സിംഗ്, ക്രിപ്റ്റോകറൻസി ട്രേഡിംഗ്, അസിൻക്രണസ് ജോലികൾ എന്നിവയും അതിലേറെയും നിലനിർത്തുന്നതിന്. നിങ്ങളുടെ സ്വന്തം ബ്ലൂടൂത്ത് ഉപകരണങ്ങൾ എങ്ങനെ നിർമ്മിക്കാമെന്ന് നിങ്ങൾ പഠിക്കും, ബാറ്ററികൾ, ചാർജറുകൾ, മൈക്രോ അഡിറ്റീവ് നിർമ്മാണത്തിനും ഉപകരണത്തിലേക്കും പ്രയോഗിക്കുന്ന 3 ഡി ഡിസൈൻ പ്രിൻസിപ്പൽമാരെ ഞാൻ പ്രകടിപ്പിക്കും, അതിനാൽ ഇന്റഗ്രേറ്റഡ് ബാറ്ററികൾ, ചാർജേഴ്സ്, ഇലക്ട്രോണിക് സർക്യൂട്ടുകൾ, ഫംഗ്ഷണൽ .ട്ട്പുട്ടുകൾ എന്നിവ ഉപയോഗിച്ച് നിങ്ങളുടെ സ്വന്തം ഉൾച്ചേർത്ത, ഹാർഡ്വെയർ ഉപകരണങ്ങൾ നിർമ്മിക്കാൻ നിങ്ങൾക്ക് കഴിയും. അവയെ ബ്ലൂടൂത്തും വെബിലും നെറ്റ്വർക്ക് ചെയ്യുക. പ്രത്യേകിച്ചും, ഒരു ഗ്രാഫിക്കൽ ഇന്റർഫേസായി അല്ലെങ്കിൽ കമാൻഡ് ലൈൻ യൂട്ടിലിറ്റിയായി ലഭ്യമാണ്, അവയുടെ ഗ്രാഫിക്കൽ ഇന്റർഫേസായി ലഭ്യമാകുന്നതും ഒരു വെബിലേക്ക് ഒരു വെബിലേക്ക് സംയോജിപ്പിക്കാനും ഞങ്ങൾ രണ്ട് കേസ് പഠനങ്ങൾ, വൈബ്രേറ്റിംഗ് മസാജർ, ഒരു വീട്ടിൽ ഫയർ. മുൻകൂട്ടി അനുഭവപ്പെടാതെ നിലത്തു നിന്ന് ഒരു വെബ്സൈറ്റ് എങ്ങനെ നിർമ്മിക്കാമെന്നും വിന്യസിക്കാനും നിങ്ങൾ പഠിക്കാം, ഇത് പ്രവർത്തനക്ഷമമായും സുരക്ഷിതമായും, മനോഹരവും ഉപയോഗപ്രദവും ഉപയോഗപ്രദവും പ്രായോഗികവും ആക്കുക. നിങ്ങളുടെ വെബ്സൈറ്റിൽ നിന്ന് സുരക്ഷിതവും പ്രായോഗികവും വീഡിയോയും ഓഡിയോയും ഉപയോഗിച്ച് മെഷീൻ പഠനവും കമ്പ്യൂട്ടർ ദർശനവും എങ്ങനെ ഉപയോഗിക്കാമെന്ന് നിങ്ങൾ പഠിക്കും, ഉപയോഗപ്രദമായ സാമ്പിളുകൾ സൃഷ്ടിക്കാൻ സംഗീതവും മോഡുലേറ്റ് ഓഡിയോയും, കൂടാതെ നിങ്ങളുടെ സോഫ്റ്റ്വെയറിലേക്കും ബിസിനസ്സിലേക്കും ആളുകളെ കൊണ്ടുവരാൻ എങ്ങനെ ഇടപഴകുന്നു. വലത് ഉപയോക്താക്കളെ ഏർപ്പെടുത്തുന്നതിലൂടെയും തെറ്റായ, പ്രായോഗിക, കൈകൾ, അതേപടി തുടരുന്നതിനും ഈ പുസ്തകം കൂടുതൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുകയും, യാന്ത്രികവും പ്രായോഗികവും, പങ്കുവഹിക്കുന്നതുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ, വെബിന് ഉപയോഗപ്രദവും പ്രായോഗികവുമായ കൈകൾ വികസിപ്പിക്കുന്നതിലൂടെയും ഇടപഴകുന്നതും. ഈ പുസ്തകം യുണിക്സ്, പ്രത്യേകിച്ച് ഡെബിയൻ (ഉബുണ്ടു), ബാഷ്, സിഎസ്എസ്, ജാവാസ്ക്രിപ്റ്റ്, HTML, സിഎസ്എസ്, ജാവാസ്ക്രിപ്റ്റ്, HTML, CSS, JavaScript, അഭ്യർത്ഥനകൾ പോലുള്ള ഉപയോഗപ്രദമായ സോഫ്റ്റ്വെയർ പാക്കേജുകളും അഭ്യർത്ഥനകൾ പോലുള്ള ഉപയോഗപ്രദമായ ബാഷ് പാക്കേജുകളും, അതുപോലെ തന്നെ ജിറ്റ്, എഫ്എഫ്എംപെഗ് പോലുള്ള ഉപയോഗപ്രദമായ ബാഷ് സോഫ്റ്റ്വെയറുകൾ. ക്രിപ്റ്റെറൻസി എങ്ങനെ ട്രേഡ് ചെയ്യാമെന്നും ക്രിപ്റ്റോകറൻസിയിലോ സാധാരണ ഡെബിറ്റ് കാർഡുകളിലോ ഉള്ള പേയ്മെന്റുകൾ അല്ലെങ്കിൽ നിങ്ങളുടെ സന്ദർശകരുടെ ഒരു പങ്ക് നിങ്ങൾ തിരഞ്ഞെടുക്കുന്നുവെങ്കിൽ നിങ്ങളുടെ വരുമാനത്തിന്റെ ഒരു പങ്ക് നിങ്ങൾ തിരഞ്ഞെടുക്കുമ്പോൾ ഞാൻ നിങ്ങളെ പഠിപ്പിക്കും. പരസ്യത്തിലൂടെ നിങ്ങളുടെ വെബ്സൈറ്റിൽ നിന്ന് എങ്ങനെ പണം സമ്പാദിക്കാമെന്ന് ഞാൻ നിങ്ങളെ പഠിപ്പിക്കും, ഇത് എങ്ങനെ വേഗത്തിലാക്കാമെന്ന് നിങ്ങളുടെ ഉപഭോക്താക്കൾ നിങ്ങളെ കണ്ടെത്താൻ തിരയുന്നതിനാലും കഴിയുന്നത്ര സാധാരണ തിരയലുകളിലും റാങ്കിംഗ്. നിങ്ങളുടെ സോഫ്റ്റ്വെയർ എങ്ങനെ വിൽക്കാമെന്ന് ഞാൻ നിങ്ങളെ പഠിപ്പിക്കും, അത് പരസ്യം ചെയ്യുക, നിങ്ങളുടെ സേവനങ്ങൾക്കായി തിരയുന്ന ക്ലയന്റുകളെ ആകർഷിക്കുക, ഇതിനകം തന്നെ ഇതിനകം നിലവിലുള്ള വഴികളിലൂടെ ഒരു പേര് നൽകുക, വിലകുറഞ്ഞതും നന്നായി പ്രവർത്തിക്കുന്നതും നന്നായി പ്രവർത്തിക്കുക. നിങ്ങൾക്കായി പ്രവർത്തിക്കുന്ന ക്ലൗഡ് കമ്പ്യൂട്ടറുകളിൽ നിങ്ങളുടെ ഡാറ്റ എങ്ങനെ സംരക്ഷിക്കാമെന്ന് ഞാൻ നിങ്ങളെ പഠിപ്പിക്കും, നിങ്ങളുടെ ഉപയോക്താക്കൾക്ക് ലഭിക്കുന്ന ഒരു വെബ്സൈറ്റ് എങ്ങനെ ആസൂത്രണം ചെയ്യാം, നിങ്ങളുടെ ഉപയോക്താക്കളെ നിങ്ങളുടെ വെബ്സൈറ്റിലേക്ക് സജ്ജമാക്കി, നിങ്ങളുടെ ഉപയോക്താക്കളെ നിങ്ങളുടെ വെബ്സൈറ്റിലേക്ക് തിരികെ കൊണ്ടുവരാം. ഈ പുസ്തകം വലിയ അളവിൽ പ്രസിദ്ധീകരിക്കുകയും വിതരണം ചെയ്യുകയും ചെയ്യുന്നതിന്റെ പ്രായോഗികത്തിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുകയും അന്തിമ ഉപയോക്താക്കൾക്ക് (നിങ്ങളുടെ കക്ഷികമായത്) ഒരു വെബ്സൈറ്റ് സൃഷ്ടിക്കുന്നതിനായി, ഒരു വെബ്സൈറ്റ് സൃഷ്ടിക്കുന്നതിനായി, നിങ്ങളുടെ സോഫ്റ്റ്വെയറും നിങ്ങളുടെ കമ്പനിയും സാധ്യമാക്കുന്ന ഒരു അപ്ലിക്കേഷൻ സാധ്യമാക്കുന്നു. നിങ്ങളുടെ സോഫ്റ്റ്വെയറിനെപ്പോലെയുള്ള പ്രായോഗികമായ വാനിറ്റി, മോഡലിംഗ്, ജോലി എന്നിവ പോലുള്ള എല്ലാ ഉപകരണങ്ങളിലും നിങ്ങൾ ആവശ്യമുള്ളത്രയും നിങ്ങളുടെ കമ്പനിയെയും ഉപയോഗിച്ച് ലഭ്യമാകുന്നതിനിടയിൽ നിങ്ങൾക്ക് ലഭ്യമായ എല്ലാ ഉപകരണങ്ങളും ഉപയോഗിച്ച് നിങ്ങൾക്കായി ലഭ്യമാകുമ്പോൾ തന്നെ നിങ്ങൾക്കായി ലഭ്യമാകുന്നതിനും നിങ്ങളുടെ കമ്പനിയെയും മികച്ച രീതിയിൽ ചിത്രീകരിക്കുന്നതിനായി നിങ്ങൾ ചില നുറുങ്ങുകളും തന്ത്രങ്ങളും പഠിക്കും. ഈ പുസ്തകത്തെ "പ്രായോഗികം എന്ന് വിളിക്കുന്നുഉദാഹരണമായി വെബ് അധിഷ്ഠിത ആഴത്തിലുള്ള പഠനവും സുരക്ഷയും ഉദാഹരണമായി "ഒരു കാരണത്താൽ, പ്രത്യേകമായി സെക്യൂരിറ്റിയിൽ പഠിക്കുന്നത്, പ്രത്യേകിച്ചും, പ്രത്യേകിച്ചും, ഇത് പ്രത്യേകമായി, പ്രത്യേകമായി, പ്രത്യേകിച്ചും, ഇത്, ഫേഷ്യൽ തിരിച്ചറിയൽ, ഇമേജ്, ഇമേജ്, വീഡിയോ മിതറേഷൻ, ഇമേജ് മെച്ചപ്പെടുത്തൽ, റെസല്യൂഷൻ മെച്ചപ്പെടുത്തൽ, ഇമേജ് അടിക്കുറിപ്പ്, ചിത്രങ്ങളുടെ സ്വഭാവം, അല്ലെങ്കിൽ അച്ചടിച്ച ഫോട്ടോകൾ പോലുള്ള മറ്റ് ജോലികൾ, അല്ലെങ്കിൽ ഒരു ഇമേജ്, അച്ചടിച്ച ഫോട്ടോ എന്നിവ പോലെ, അത് അസാധ്യമാണ്. മുഖം. നിങ്ങൾക്ക് ഒരു സെർവർ കമ്പ്യൂട്ടർ, സാധാരണയായി ഒരു ഉപയോക്തൃനാമത്തിനോ പുതിയ ഐപി വിലാസത്തിനോ വേണ്ടി ഒരു കമ്പ്യൂട്ടറായും, നിങ്ങൾ ഒരു കമ്പ്യൂട്ടർ, നിങ്ങൾ, ഒരു കമ്പ്യൂട്ടറൻ, അത്, നിങ്ങളുടെ സോഫ്റ്റ്വെയറായി, നിങ്ങളുടെ സോഫ്റ്റ്വെയറായി, നിങ്ങളുടെ സോഫ്റ്റ്വെയറായി, നിങ്ങളുടെ സോഫ്റ്റ്വെയറായി, നിങ്ങളുടെ സോഫ്റ്റ്വെയറായി, നിങ്ങളുടെ സോഫ്റ്റ്വെയറായി മാറ്റാം ആണ്. ഉപയോഗിക്കുക). ഗുരുതരാദരായ സുരക്ഷിതത്വമുള്ള സോഫ്റ്റ്വെയർ നിർമ്മിക്കുന്ന ആർക്കും ഇത് സൂചിപ്പിക്കുന്നതിൽ ചില ബോധമുണ്ട്. സോഫ്റ്റ്വെയർ അന്തർലീനമായി സുരക്ഷിതമല്ല, കാരണം ഇത് ആക്സസ് ചെയ്യുന്നതിന് ഞങ്ങൾ ഉപയോഗിക്കുന്ന ഉപകരണങ്ങളും അക്കൗണ്ടുകളും എല്ലായ്പ്പോഴും ഞങ്ങളുടെ കൈവശമുള്ളതല്ല, മാത്രമല്ല അവ സോഫ്റ്റ്വെയറിനായുള്ള മോശം ഉദ്ദേശ്യത്തോടെ ആരുടെയും കൈകളിലായിരിക്കാം, അതിനാൽ സോഫ്റ്റ്വെയർ തന്നെ ഒരു അപകടസാധ്യത സൃഷ്ടിച്ചേക്കാം. ഇത് ഈ പുസ്തകത്തിന്റെ കേന്ദ്രീകൃതമാണ്. ഒരു നെറ്റ്വർഡുചെയ്ത കമ്പ്യൂട്ടർ സ്ഥിരസ്ഥിതിയായി സ്ഥിരസ്ഥിതിയായി സുരക്ഷിതമാക്കിയതും സെഷ് അല്ലെങ്കിൽ സുരക്ഷിത ഷെൽ കീയും സുരക്ഷിതമാണ്, കൂടാതെ സെർവറിൽ തന്നെ പ്രവർത്തിക്കുന്ന കലാ സുരക്ഷാ ഉപകരണങ്ങളുടെ അവസ്ഥയും വെബ് സെർവർ നൽകുന്നു. ഉപയോക്താവിന്റെ വെബ് ബ്ര browser സറിലേക്ക് വെബ് സെർവറിന് ഉണ്ട്, ഇത് ഉപയോക്താവിന്റെ ഉപകരണത്തിന്റെ ഏറ്റവും ശക്തമായ ഭാഗമാണ്, കാരണം ഉപയോക്താവിന് നെറ്റ്വർക്ക് ചെയ്ത സോഫ്റ്റ്വെയർ ആക്സസ് ചെയ്യാൻ കഴിയുന്ന സ്ഥലമാണിത്. ഈ ടൂൾകിറ്റിന് വാചകം നൽകാൻ കഴിയും, നിങ്ങൾ കാണുന്ന വെബ്പേജുകൾ, കൂടാതെ ചിത്രങ്ങൾ, ഓഡിയോ വീഡിയോ, വളകൾ, ഫോക്സ് ഇംപ്ലോഡുകൾ എന്നിവയും, കൂടാതെ, ഡാറ്റയുമായി വായിക്കുകയും എഴുതുകയും ചെയ്യാം. സൈറ്റ്. നിങ്ങളുടെ കൈവശമുള്ള എല്ലാ ഉപകരണങ്ങളും ഉപയോഗിച്ച്, ഒരു സുരക്ഷിത വെബ്സൈറ്റ് നിർമ്മിക്കുന്നതിനായി നിങ്ങൾ ഈ പുസ്തകം ഉപയോഗിച്ച് നിങ്ങൾ സ്വയം സഹായിക്കും, ഒപ്പം നിങ്ങൾക്കായി പ്രവർത്തിക്കുന്ന ഒരു സുരക്ഷിത നെറ്റ്വർക്ക് സിസ്റ്റം സിസ്റ്റം മൊത്തത്തിൽ, നിങ്ങളുടെ കൽപന, തോന്നുക

എവിടെ നിന്ന് ആരംഭിക്കണം: നിങ്ങൾക്ക് ആവശ്യമുള്ള കൃത്യമായ കോഡിന് മുമ്പുള്ള കൃത്യമായ കോഡിനുമുമ്പ് ഞാൻ ഈ പുസ്തകം ആരംഭിക്കാൻ സ്വാഗതം, പ്രത്യേകിച്ചും, മേൽപ്പറഞ്ഞ ഏതെങ്കിലും ഉപകരണങ്ങളിൽ നിങ്ങൾക്ക് പരിചയമുണ്ടെങ്കിൽ, ഈ പുസ്തകത്തിൽ ഞാൻ വിശദമായി വിവരിക്കുകയും പ്രമാണം ചെയ്യുകയും അതിന്റെ പ്രായോഗിക ഉദാഹരണങ്ങൾ നൽകുകയും ചെയ്യും. നിങ്ങൾക്ക് എഴുത്ത് കോഡിൽ അനുഭവപ്പെട്ടില്ലെങ്കിൽ, ഈ പുസ്തകം എല്ലാം വായിക്കാൻ ഞാൻ വളരെയധികം ശുപാർശ ചെയ്യുന്നു, പ്രത്യേകിച്ചും മുമ്പത്തെ വിഭാഗങ്ങൾ വായിക്കാൻ ശുപാർശ ചെയ്യുക, ഈ പുസ്തകം നിങ്ങൾക്ക് ശരിയാണെന്ന് ഉറപ്പാക്കാൻ മുൻ വിഭാഗംകൾ വായിക്കാൻ ശുപാർശ ചെയ്യുന്നു. ഈ പുസ്തകം നിങ്ങൾക്ക് ശരിയല്ലെങ്കിൽ, വെബ് വികസനത്തെക്കുറിച്ച് സ്വയം പഠിക്കാൻ താൽപ്പര്യപ്പെടുന്ന ഒരു സുഹൃത്ത് അല്ലെങ്കിൽ ബന്ധുക്കൾക്ക് ഇത് നൽകുന്നത് പരിഗണിക്കുക, ഞാൻ നിങ്ങളെ ഒരു അധ്യാപകനെന്ന നിലയിൽ, അല്ലെങ്കിൽ മറ്റ് അധ്യാപകർ എനിക്ക് മുമ്പ് ചെയ്തുവെന്ന് പരിഗണിക്കുക. നിങ്ങൾ ആഗ്രഹിക്കുന്ന ഇടത്ത് ആരംഭിക്കുക, നിങ്ങൾ ഒരു ഉപയോഗപ്രദമായ അപ്ലിക്കേഷൻ നിർമ്മിക്കാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, മികച്ച ഉപയോക്താക്കൾ മനസ്സിൽ നിർണ്ണയിക്കപ്പെടുന്നത് പരിഗണിക്കുക: നിങ്ങളുടെ ഉപഭോക്താവിനെ അറിയുക. ഇപ്പോൾ നിങ്ങൾ എന്നെ അറിയുന്നു, ഈ പുസ്തകം നിങ്ങൾക്കറിയാം, ആരംഭിക്കാൻ നിങ്ങൾ തയ്യാറാണ്. ആരംഭിക്കാൻ, ഒരു കമ്പ്യൂട്ടർ നേടുക (ഒരു ബോക്സ് സ്റ്റോറിൽ നിന്നുള്ള ഏറ്റവും വിലകുറഞ്ഞ ലാപ്ടോപ്പ്, ആമസോൺ, അല്ലെങ്കിൽ പഴയ ഡെസ്ക്ടോപ്പ് പ്രവർത്തിക്കുന്നത്, നിങ്ങൾക്കായി പ്രവർത്തിക്കുന്ന രീതിയിൽ സജ്ജമാക്കി.

ഈ പുസ്തകം എങ്ങനെ വായിക്കാം: വാചകം ഹൈലൈറ്റ് ചെയ്തത്, വാചകം ഒരു കമാൻഡ് പ്രോംപ്റ്റിൽ ഉൾപ്പെടുന്നുവെന്ന് സൂചിപ്പിക്കുന്നു, അവിടെ നിങ്ങൾ പ്രവർത്തിക്കുന്ന കോഡ് എഴുതാം. കമാൻഡ് പ്രോംപ്റ്റ് വളരെയധികം കീബോർഡ് ഫോക്കസ് ചെയ്യുകയും ക്ലിക്കുചെയ്യാനാകില്ല, നിങ്ങളുടെ വർക്ക്ഫ്ലോ വേഗത്തിലാക്കാനും നിങ്ങൾക്ക് കാര്യങ്ങൾ എളുപ്പമാക്കാനും ആവശ്യമില്ല.

ആമുഖം: നമുക്ക് മുങ്ങാം. ഞങ്ങൾ ഒരു പ്രാദേശിക മെഷീനിൽ കെട്ടിട കോഡ് നിർമ്മിച്ച് ഇന്റർനെറ്റിലേക്ക് കണക്റ്റുചെയ്തിരുന്ന് ആരംഭിക്കും. ഇത് ആരംഭിക്കുന്നത് സുരക്ഷിതമാണ്, ഒന്നും നഷ്ടപ്പെട്ടില്ല, നിങ്ങൾക്ക് എളുപ്പമാണ്. നിങ്ങളുടെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തെ ആശ്രയിച്ച്, ഒരു ബാഷ് ഷെല്ലിൽ പ്രവേശിക്കുന്നത് അൽപ്പം വ്യത്യസ്തമായിരിക്കും. മാക് ഒഎസിനായി, ഈ സമയത്ത് ഒരു വെർച്വൽ മെഷീൻ ഇൻസ്റ്റാൾ ചെയ്യാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു, കാരണം നിങ്ങൾക്ക് ഒരു വെർച്വൽ മെഷീനുമായി ഏറ്റവും അനുയോജ്യത ലഭിക്കും. വെർച്വൽബോക്സും പാരലെല്ലുകളും പോലുള്ള വിവിധ ദാതാക്കളായ നിങ്ങൾക്കായി ഒരു വെർച്വൽ മെഷീൻ നടത്താം, എന്നിരുന്നാലും നിങ്ങൾക്കായി നേരിട്ട് ഇൻസ്റ്റാൾ ചെയ്യാൻ കഴിയും, അത് വേഗത്തിൽ, കാര്യമായ ഒരു അനുഭവം സൃഷ്ടിക്കാൻ ശുപാർശ ചെയ്യുന്നു. നിങ്ങൾ ലിനക്സ് അല്ലെങ്കിൽ വിൻഡോകൾ ഉപയോഗിക്കുകയാണെങ്കിൽ, ഞാൻ ശുപാർശ ചെയ്യുന്ന ഒരു പ്രോജക്റ്റ് സൃഷ്ടിക്കുന്നത് വളരെ എളുപ്പമായിരിക്കണം. നിങ്ങളുടെ ടെർമിനൽ തുറക്കുക, നിങ്ങൾ ഫിറ്റ് കാണുന്നതുപോലെ വലുപ്പം ക്രമീകരിക്കുക, ഘട്ടം 2 പിന്തുടരുക. നിങ്ങൾ വിൻഡോസ് ഉപയോഗിക്കുകയാണെങ്കിൽ, ദയവായി ഘട്ടം 1 പിന്തുടരുക.

ഘട്ടം 1: - വിൻഡോസ് ഉപയോക്താക്കൾ മാത്രം വിൻഡോസിൽ, അഡ്മിനിസ്ട്രേറ്ററായും ടൈപ്പുചെയ്യാനും വിൻഡോസ്, കമാൻഡ് പ്രോംപ്റ്റ് തുറക്കുക wsl -install

ഘട്ടം 2: - നിങ്ങൾ വിൻഡോസ് ഉപയോഗിക്കുന്നില്ലെങ്കിൽ ഇവിടെ തുടരുക, അല്ലെങ്കിൽ സ്റ്റെപ്പ് 1 ഇവിടെ നിന്ന് ഒഴിവാക്കുക ഒരു തുറന്ന ടെർമിനലിൽ, (വിൻഡോകൾ, ടെർമിനൽ, മാക് അല്ലെങ്കിൽ ലിനക്സ്, അല്ലെങ്കിൽ സമാനമായ പേര് എന്നിവയെ ആശ്രയിച്ച്), ഒരു പ്രോജക്റ്റ് സൃഷ്ടിച്ചുകൊണ്ട് ആരംഭിക്കുക. ഒരു ഡയറക്ടറി സൃഷ്ടിക്കുന്ന mkdir കമാൻഡ് ഉപയോഗിച്ച് ഞങ്ങൾ ഇത് ചെയ്യുന്നു. നിങ്ങളുടെ പ്രോജക്റ്റ് സംഭരിക്കുന്നതിന് നിങ്ങൾ ഒരു ഡയറക്ടറി സൃഷ്ടിക്കേണ്ടതുണ്ടെങ്കിൽ, ഡയറക്ടറിയിലേക്ക് മാറാൻ CD കമാൻഡ് ഉപയോഗിക്കുക

സിഡി / പാത്ത് / ടു / ഡയറക്ടറി - നിങ്ങളുടെ ലക്ഷ്യസ്ഥാന ഡയറക്ടറിക്ക് മുമ്പുള്ള ഫോൾഡറുകൾ (ഫയലുകൾ), നിങ്ങളുടെ സ്ഥിരസ്ഥിതി പാത ~ അല്ലെങ്കിൽ / ഹോം / ഉപയോക്തൃനാമം (എവിടെയാണ് നിങ്ങളുടെ ഉപയോക്തൃനാമം). സ്ഥിരസ്ഥിതി ഡയറക്ടറിയിലേക്ക് മാറാൻ, സിഡി അല്ലെങ്കിൽ സിഡി to to teck MKDIR ഉദാഹരണം - "ഉദാഹരണം" മാറ്റിസ്ഥാപിക്കുക ഡയറക്ടറിയുടെ പേര് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുക

ഇപ്പോൾ നിങ്ങളുടെ പ്രോജക്റ്റിനായി നിങ്ങൾക്ക് ഒരു പ്രവർത്തന ഡയറക്ടറി ഉണ്ട്. ഈ ഡയറക്ടറി സംരക്ഷിക്കുന്നത് വളരെ പ്രധാനമാണ് നിങ്ങൾ മറ്റൊരു മെഷീനിലേക്ക് മാറുകയോ നിങ്ങൾ എഴുതുകയോ ചെയ്യേണ്ട കോഡ് വിന്യസിക്കുക, അതിനാൽ ഇത് വെബിന് തയ്യാറാണ്, അടുത്ത കുറച്ച് ഘട്ടങ്ങളിൽ നിങ്ങളുടെ ഡയറക്ടറി ബാക്കപ്പ് ചെയ്യുന്നതിന് ഞങ്ങൾ ഒരു സ്ക്രിപ്റ്റ് നിർമ്മിക്കും. എന്നാൽ ഒരു സ്ക്രിപ്റ്റ് പണിയുന്നത് ഒരു ചെറിയ കോഡ് എടുക്കും, കഴിയുന്നത്ര ഉപയോഗപ്രദമാകാൻ കോഡ് യാന്ത്രികമാക്കേണ്ടതുണ്ട്. അതിനാൽ സ്ക്രിപ്റ്റുകൾ ആദ്യം നിർമ്മിക്കാൻ ഒരു സ്ക്രിപ്റ്റ് നിർമ്മിക്കാം. സ്ക്രിപ്റ്റ് സൃഷ്ടിക്കുകയും അത് നടപ്പിലാക്കുകയും ചെയ്തുകൊണ്ട് നമുക്ക് ആരംഭിക്കാം. ഞങ്ങൾ സുഡോ, chmod ഉപയോഗിക്കുകയും ഇതിനായി സ്പർശിക്കുകയും ചെയ്യാം, സ്ക്രിപ്റ്റ് "എസ്ക്രിപ്റ്റ്" എന്ന് വിളിക്കുക.

sudo touch /usr/bin/ascript
sudo chmod a+x /usr/bin/ascript
sudo nano /usr/bin/ascript

ഇപ്പോൾ ഞങ്ങൾ തിരക്കഥ സൃഷ്ടിച്ചു, അത് നടപ്പിലാക്കി, അത് എഡിറ്റുചെയ്യാൻ തയ്യാറാണ്. ക്ലിക്കുചെയ്യാതെ തന്നെ വാചകം എഡിറ്റുചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു ടെക്സ്റ്റ് എഡിറ്ററാണ് നാനോ. ഒരു ഗ്രാഫിക്കൽ യൂസർ ഇന്റർഫേസ് ഉപയോഗിക്കുന്നതിനേക്കാൾ വളരെ എളുപ്പമാണ്. നാനോ ഉപയോഗിച്ച് ഒരു ഫയൽ എഡിറ്റുചെയ്യാൻ, നാനോ ഉപയോഗിക്കുക, തുടർന്ന് ഫയലിലേക്കുള്ള പാത ഉപയോഗിക്കുക. ഒരു സ്ക്രിപ്റ്റ് നിർമ്മിക്കുന്ന ഒരു സ്ക്രിപ്റ്റ് നിർമ്മിക്കാൻ, ഞങ്ങളുടെ സ്ക്രിപ്റ്റ് ആദ്യം ഞങ്ങളുടെ സ്ക്രിപ്റ്റ് ചെയ്യുന്നതിന് സമാനമാണ്. ഞങ്ങൾ മുകളിലുള്ള അതേ കോഡ് ഉപയോഗിക്കും, സ്ക്രിപ്റ്റിന്റെ പേര്, "എസ്ക്രിപ്റ്റ്" എന്നത് ഒരു ആർഗ്യുമെന്റ് പാരാമീറ്റർ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കും. സുഡോ എസ്ക്രിപ്റ്റ് ന്യൂസ്ക്രിപ്റ്റ് ലളിതമായി ടൈപ്പുചെയ്ത് സ്ക്രിപ്റ്റ് എന്ന് വിളിക്കാൻ ഇത് ഞങ്ങളെ അനുവദിക്കുന്നു, ഏത് പോയിന്റിൽ നിങ്ങളുടെ സ്ക്രിപ്റ്റിന്റെ പേരിനൊപ്പം "ന്യൂസ്ക്രിപ്റ്റ്" മാറ്റിസ്ഥാപിച്ച് ഏതെങ്കിലും പുതിയ സ്ക്രിപ്റ്റ് സൃഷ്ടിക്കാൻ കഴിയും. നാനോയിലെ കോഡ് ഇങ്ങനെയായിരിക്കണം:

sudo touch /usr/bin/$1
sudo chmod a+x /usr/bin/$1
sudo nano /usr/bin/$1

നാനോ അടയ്ക്കുന്നതിന്, ഞങ്ങൾക്ക് നിയന്ത്രണ കീ അമർത്തിപ്പിടിക്കാനും എക്സ് അമർത്താനും കഴിയും, തുടർന്ന് y, ഞങ്ങൾ ഫയൽ സംരക്ഷിക്കുന്നു, തിരികെ കൊണ്ടുവന്ന് മടങ്ങുക. ഒരു സ്ക്രിപ്റ്റ് എഡിറ്റുചെയ്യാൻ ഈ മൂന്ന് കമാൻഡുകൾ ടൈപ്പുചെയ്യുന്നതിനുപകരം, സ്ക്രിപ്റ്റ് വീണ്ടും എഡിറ്റുചെയ്യാൻ ഞങ്ങൾക്ക് സുഡോ എസ്ക്രിപ്റ്റ് ആസ്ക്രിപ്റ്റ് ടൈപ്പുചെയ്യാൻ കഴിയും. ഈ കൃതികൾ! ഏതെങ്കിലും പുതിയ സ്ക്രിപ്റ്റ് അത് ഷെല്ലിൽ വിളിച്ച് എളുപ്പത്തിൽ പ്രവർത്തിപ്പിക്കാൻ കഴിയും. നമുക്ക് ഇപ്പോൾ ഞങ്ങളുടെ ജോലി സംരക്ഷിക്കാം: ഞങ്ങളുടെ പുതിയ സ്ക്രിപ്റ്റ് സംരക്ഷിക്കാൻ ഒരു ബാക്കപ്പ് സ്ക്രിപ്റ്റ് എഴുതാം, തുടർന്ന് ബാക്കപ്പ് സ്ക്രിപ്റ്റ് ബാക്കപ്പ് ചെയ്യുന്നതിന് അത് ബാക്കപ്പ് ഡയറക്ടറിയിൽ ബാക്കപ്പ് ചെയ്യാം.

sudo ascript backup

ഇപ്പോൾ, നാനോയിൽ:

sudo cp /usr/bin/backup /path/to/directory/
sudo cp /usr/bin/ascript /path/to/directory/

Mekdir ഉപയോഗിച്ച് നിങ്ങൾ സൃഷ്ടിച്ച പ്രോജക്റ്റിലേക്കുള്ള പാത എവിടെ / PATH / VER / ഡയറക്ടറി എവിടെയാണ്. ഇതുപോലുള്ള ആവർത്തിച്ചുള്ള പാതകളും ഒരു ലിസ്റ്റും ഉപയോഗിച്ച് ഇത് എങ്ങനെ പകർത്താമെന്ന് പിന്നീട് ഞങ്ങൾ പഠിക്കും, അത് കോഡ് കുറവാണ്, പക്ഷേ ഇപ്പോൾ ഇത് ലളിതവും കുറച്ച് വരികളും സൂക്ഷിക്കാം. ഈ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കാനും നിങ്ങളുടെ കോഡ് ബാക്കപ്പ് ചെയ്യാനും, കൺട്രോൾ + x, y ഉപയോഗിച്ച് നാനോയിലെ ഫയൽ സംരക്ഷിക്കുക, നിങ്ങളുടെ ഷെല്ലിലേക്ക് ചുവടെ ടൈപ്പുചെയ്യുക

backup

ഈ പുസ്തകം വായിക്കുമ്പോൾ ഒരു പാസ്വേഡിനായി നിങ്ങൾ ആവശ്യപ്പെടുകയാണെങ്കിൽ, ദയവായി നിങ്ങളുടെ ഉപയോക്തൃ പാസ്വേഡ് ശരിയായി നൽകുക, നിങ്ങൾക്ക് കമാൻഡ് വീണ്ടും പ്രവർത്തിപ്പിക്കുന്നതിന് മൂന്ന് ശ്രമങ്ങൾ ലഭിക്കും. നിങ്ങൾക്ക് മുകളിലേക്കും താഴേക്കും കമാൻഡുകൾ ചെയ്യാനും അവ എഡിറ്റുചെയ്യാനും കഴിയും, നിങ്ങൾ രണ്ടുതവണ എന്തെങ്കിലും പ്രവർത്തിപ്പിക്കേണ്ടതുണ്ടോ. ഒരു കമാൻഡ് തിരഞ്ഞെടുക്കുന്നതിന്, ഒരു കമാൻഡ് തിരഞ്ഞെടുക്കുന്നതിന്, ഒരു കമാൻഡ് തിരഞ്ഞെടുക്കുന്നതിന്, ഒരു കമാൻഡ് തിരഞ്ഞെടുക്കുന്നതിന് ലളിതമായി അമർത്തുക, കൂടാതെ, അത് വലത്, ഇടത് അമ്പുകൾ, കീബോർഡ് ഇല്ലാതാക്കുക, തിരികെ പ്രവർത്തിപ്പിക്കുക എന്നിവ.

അഭിനന്ദനങ്ങൾ! നിങ്ങളുടെ പ്രവർത്തന ഡയറക്ടറിയിലെ രണ്ട് പ്രധാന ഷെൽ സ്ക്രിപ്റ്റുകൾ ബാക്കപ്പ് ചെയ്യുന്ന ആകർഷണീയമായ ബാക്കപ്പ് സ്ക്രിപ്റ്റ് സൃഷ്ടിക്കാൻ നിങ്ങൾ കഴിഞ്ഞു. പ്രോജക്റ്റ് വലുതാകുമ്പോൾ ഞങ്ങൾ പിന്നീട് കാര്യങ്ങൾ നീക്കിയേക്കാം, പക്ഷേ ഇത് ഇപ്പോൾ പ്രവർത്തിക്കുന്നു. നമുക്ക് ക്ലൗഡിൽ ബാക്കപ്പ് ചെയ്യാൻ നമുക്ക് മുന്നോട്ട് പോകാം, ഇതിനായി ഞങ്ങൾ Github ഉപയോഗിക്കാം (ബാക്കപ്പിനായി മറ്റ് ജിറ്റ് പരിഹാരങ്ങൾ ഉണ്ടെങ്കിലും നിങ്ങൾ ഒരു സെർവറിലേക്ക് എഡിറ്റുചെയ്യുന്നത് ഒരു സെർവറിയിലേക്കോ കീടാക്കുന്നതിനും നിങ്ങളെ സഹായിക്കുന്നു. നിങ്ങളുടെ സോഫ്റ്റ്വെയർ സംരക്ഷിക്കുന്നതിൽ ഇത് ചെയ്യുന്നത് പ്രധാനമാണ്, പ്രത്യേകിച്ചും ഒരു വരി കോഡ് പരാജയപ്പെടുമ്പോൾ, നിങ്ങൾ സ്വപ്രേരിതമായി ബാക്കപ്പ് ചെയ്യാനുള്ള അവസരം ലഭിച്ചില്ലെങ്കിൽ, നിങ്ങളുടെ കോഡ് ബാക്കപ്പ് ചെയ്യാത്തപ്പോൾ നിങ്ങളുടെ കോഡ് ബാക്കപ്പ് ചെയ്യാനായില്ലെങ്കിൽ, നിങ്ങളുടെ കോഡ് പിന്തുണയ്ക്കില്ല.

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

സുഡോ എസ്ക്രിപ്റ്റ് ബാക്കപ്പ് കമാൻഡ് പ്രവർത്തിപ്പിച്ച് ബാക്കപ്പ് സ്ക്രിപ്റ്റ് ഉപയോഗിച്ച് ഞങ്ങളുടെ ജോലി ചെയ്യാനുള്ള കുറച്ച് കമാൻഡുകൾ ചേർക്കാം.

# ...

സംരക്ഷിക്കാൻ x നിയന്ത്രിക്കുക.

ഇപ്പോൾ ഈ പ്രോജക്റ്റിനായി ഞങ്ങൾ ഒറ്റത്തവണ കോൺഫിഗറേഷൻ ചെയ്യേണ്ടതുണ്ട്. ഇത് ഉടൻ തന്നെ ഒരു ജിറ്റ് പ്രോജക്റ്റ് ആയിരിക്കും, ഞങ്ങൾ ഒരു ജിറ്റ് ശേഖരത്തിൽ നിന്ന് വിന്യസിക്കുമ്പോൾ ഓരോ കമാനുകളും ഞങ്ങൾ ടൈപ്പ് ചെയ്യേണ്ടതില്ല, പക്ഷേ ഞങ്ങളുടെ വിന്യാസ സ്ക്രിപ്റ്റുകൾ എഴുതുമ്പോൾ ഞങ്ങൾക്ക് ഇതിന്റെ ഹാംഗ് ലഭിക്കും. ആരംഭിക്കുന്നതിന്, ഞങ്ങൾ ശരിയായ ഡയറക്ടറിയിലാണെന്നും ജിറ്റ് ശേഖരം സമാരംഭിക്കുകയും എസ്എസ്എച്ച് കീകൾ സൃഷ്ടിക്കുകയും ചെയ്യട്ടെ.

cd /path/to/directory
git init
git branch -m master
ssh-keygen

ഞങ്ങൾ SSH-കീൻ ടൈപ്പുചെയ്തതിനുശേഷം, പുതിയ കീയെ ഹോം ഫോൾഡറിൽ വിളിക്കണം .എസ്എസ്എച്ച്. ഇതിനെ id_rsa.pub എന്ന് വിളിക്കുന്നു. ഈ കീ കണ്ടെത്തി അത് പകർത്തുക. അത് കാണാൻ,

cd ~
cat .ssh/id_rsa.pub

നിങ്ങളുടെ അക്കൗണ്ടിലേക്ക് ssh കീ ചേർക്കുന്നതിന് മുമ്പ് അവസാന കമാൻഡ് നൽകി മടക്കിനൽകുന്ന വാചകം പകർത്തുക, നിങ്ങളുടെ ജിറ്റ് ദാതാവിനൊപ്പം ഒരു അക്കൗണ്ട് സൃഷ്ടിക്കുക. നിങ്ങൾക്ക് ഒരു അക്കൗണ്ട് ഉണ്ടായിരുന്നെങ്കിൽ, മെനുവിലെ SSH, GPG കീകളിൽ നിങ്ങളുടെ SSH കീ ചേർക്കുന്നതിന് മുമ്പ് മുകളിൽ വലത് മെനുവിൽ ക്ലിക്കുചെയ്ത് ക്രമീകരണങ്ങൾ നൽകുക. ഒരു SSH കീ ചേർക്കുക, അത് ഒട്ടിച്ച് അത് ഒട്ടിച്ച് ഒരു ശീർഷകം നൽകുകയും ഒരു പുതിയ ശേഖരം സൃഷ്ടിക്കുകയും ചെയ്യുക. ഇത് മറ്റ് ജിറ്റ് ദാതാക്കൾക്ക് സമാനമാണ്, നിങ്ങൾ അവരുടെ ഡോക്യുമെന്റേഷൻ വായിക്കേണ്ടതുണ്ട്. പുതിയ റിപ്പോസിറ്ററി കോൺഫിഗറേഷനിൽ, നിങ്ങളുടെ ശേഖരം നൽകുക ഒരു വിവരണാത്മക നാമം നൽകുക, നിങ്ങൾ അത് പ്രസിദ്ധീകരിക്കണോ എന്ന് തീരുമാനിക്കുക, കൂടാതെ ഉൾപ്പെടുത്തലിനായി ഫയലുകളൊന്നും ക്രമീകരിക്കുന്നില്ലെന്ന് ഉറപ്പാക്കുക. ശേഖരം സൃഷ്ടിച്ചുകഴിഞ്ഞാൽ, SSH URL ഉപയോഗിച്ച് ക്ലോൺ പകർത്തി ഇനിപ്പറയുന്ന കമാൻഡിലേക്ക് ഒട്ടിക്കുക.

git remote add git://… (your remote URL)

ഇപ്പോൾ നിങ്ങൾക്ക് സിഡി ഉപയോഗിച്ച് നിങ്ങളുടെ ശേഖരത്തിലേക്ക് മടങ്ങാൻ കഴിയും, നിങ്ങൾക്ക് ഇത് പരിചിതമാകും. ബാക്കപ്പ് ഉപയോഗിച്ച് ഇപ്പോൾ നിങ്ങളുടെ ബാക്കപ്പ് സ്ക്രിപ്റ്റ് പരീക്ഷിക്കുക

കൊള്ളാം! ഇപ്പോൾ നമുക്ക് കോഡിംഗ് ലഭിക്കാൻ കഴിയും. നമുക്ക് ബാഷ്, ജിറ്റ് എന്നിവയിൽ നല്ലൊരു ഗ്രാഹ്യമുണ്ടെന്ന് ഇപ്പോൾ kjango ഇപ്പോൾ ഇൻസ്റ്റാൾ ചെയ്യാം. ഡാംഗോ ഇത് ഞങ്ങളുടെ സോഫ്റ്റ്വെയർ തിരികെ കൊണ്ടുവരാൻ അനുവദിക്കും, ഇത് ഇതും ചെയ്യാൻ കഴിയും, പക്ഷേ ഇത് ലളിതമായ സുരക്ഷിത നടപ്പാക്കലാക്കും (ഇത് കൂടുതൽ എളുപ്പത്തിൽ ക്രമീകരിക്കാനും ക്രമീകരിക്കാനും കഴിയും).

ഉബുണ്ടുവിൽ സോഫ്റ്റ്വെയർ ഇൻസ്റ്റാൾ ചെയ്യുന്നതിന്, ഞങ്ങൾ sudo apt-get കമാൻഡ് ഉപയോഗിക്കും. ആദ്യം, ഞങ്ങൾക്ക് ഇതിനകം ഉണ്ടായിരുന്ന സോഫ്റ്റ്വെയർ അപ്ഡേറ്റ് ചെയ്ത് അപ്ഗ്രേഡുചെയ്യാം. സുഡോ ആപ്റ്റ്-ഗെറ്റ് അപ്ഡേറ്റും സുഡോ ഉപ്പ് അപ്ഗ്രേഡും ഉപയോഗിച്ച് ഇത് ചെയ്യാൻ കഴിയും -yy. അടുത്തതായി, ഇനിപ്പറയുന്ന കമാൻഡ് ഉപയോഗിച്ച് പൈത്തൺ, ഞങ്ങളുടെ വെർച്വൽ പരിസ്ഥിതി എന്നിവ ഇൻസ്റ്റാൾ ചെയ്യാം: sudo apt-got-glast python3-python3-venev

ഉബുണ്ടു ഉദാഹരണത്തിലെ സോഫ്റ്റ്വെയർ ഇൻസ്റ്റാളുകളിൽ സോഫ്റ്റ്വെയർ ഇൻസ്റ്റാളുകളിൽ നിങ്ങൾ ദബാംഗോയുമായി പോകേണ്ടത് ഇതാണ്. വിൻഡോസിനും ലിനക്സിനും ഇത് വളരെ നേരെയാകണം, പക്ഷേ മാക് സംബന്ധിച്ച് നിങ്ങൾക്ക് ഒരു വെർച്വൽബോക്സ് അല്ലെങ്കിൽ പാരലെൽസ് ഡെസ്ക്ടോപ്പ് ഉപയോഗിച്ച് ഒരു വെർച്വൽ മെഷീനും ലിനക്സും ഇൻസ്റ്റാൾ ചെയ്യാനും ഒരു ഉബുണ്ടു പരിസ്ഥിതി സജ്ജീകരിക്കുന്നതിന് അതിനു മുകളിലുള്ള ഘട്ടങ്ങൾ പുന ate സൃഷ്ടിക്കാനും നിങ്ങൾ ആഗ്രഹിക്കുന്നു. ഈ സാഹചര്യത്തിൽ ഉബുണ്ടു നിർണ്ണായകമാണ്, കാരണം ഇത് വെബ്സൈറ്റുകൾ പ്രവർത്തിപ്പിക്കുന്നതാണ്, മേൽപ്പറഞ്ഞ എല്ലാ സോഫ്റ്റ്വെയറുകളും ഉപയോഗിച്ച് വെബ്സൈറ്റുകൾ ഹോസ്റ്റുചെയ്യാൻ ഇത് പ്രാപ്തരാക്കുന്നു.

നമുക്ക് ജാങ്കോയിലേക്ക് കുഴിക്കാം.

ഞങ്ങളുടെ ഡയറക്ടറിയിൽ വീണ്ടും, സിഡി ഉപയോഗിച്ച്:

python -m venv venv # കോഡ് സംഭരിച്ചിരിക്കുന്ന വെർച്വൽ പരിസ്ഥിതി സൃഷ്ടിക്കുന്നു
source venv/bin/activate # വെർച്വൽ പരിസ്ഥിതി സജീവമാക്കുന്നു
django-admin startproject mysite . # എന്റെ നിലവിലെ ഡയറക്ടറിയിൽ ഞാൻ ആരംഭിക്കുന്ന പ്രോജക്റ്റാണ് മൈസൈറ്റ്.

കാർങ്കോ ഞങ്ങളെ ആരംഭിക്കുകയാണ്, കാരണം ജാങ്കോയെ ഹോസ്റ്റുചെയ്യുന്നു, മാത്രമല്ല ഇത് ഒരു അടിസ്ഥാന പ്രാദേശിക വെബ്സൈറ്റ് മുകളിലേക്കും പ്രവർത്തിപ്പിക്കുന്നതിനും ആവശ്യമായതെല്ലാം ചെയ്യുന്നു. ഇപ്പോൾ ഞങ്ങൾക്ക് ജാങ്കോ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ട്, ഞങ്ങൾക്ക് എങ്ങനെ വേണ്ടതാണെന്ന് പ്രവർത്തിക്കാൻ ക്രമീകരണങ്ങൾ അൽപ്പം എഡിറ്റുചെയ്യാം. ആദ്യം, നമുക്ക് ഒരു പുതിയ അപ്ലിക്കേഷൻ സൃഷ്ടിക്കാം

python manage.py startapp feed

ആദ്യ അപ്ലിക്കേഷന് തീറ്റ എന്ന് വിളിക്കും. അപ്ലിക്കേഷനെ നിങ്ങൾ ഇഷ്ടപ്പെടുന്നതെന്തും എന്ന് വിളിക്കും, ഞങ്ങൾ പുതിയ അപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കും, പക്ഷേ ഓരോ അപ്ലിക്കേഷനുകളുടെയും പേര് ഓരോ തവണയും ക്രമീകരണം സ്ഥിരമായിരിക്കണം. ഒരു പുതിയ അപ്ലിക്കേഷൻ ചേർക്കാൻ, ഞങ്ങൾ എല്ലായ്പ്പോഴും ക്രമീകരണങ്ങൾ എഡിറ്റുചെയ്യും. നാനോ ഉപയോഗിച്ച്,

nano app/settings.py

ക്രമീകരണങ്ങളിൽ, ഇൻസ്റ്റാളുചെയ്ത തീയതി_അപ്പ് കണ്ടെത്തി [] 3 വരികളായി വേർതിരിക്കുക. ശൂന്യമായ സെന്റർ ലൈനിൽ നാല് ഇടങ്ങൾ ഉപയോഗിച്ച്, 'ഫീഡ്' അല്ലെങ്കിൽ നിങ്ങളുടെ അപ്ലിക്കേഷന്റെ പേര് ചേർക്കുക. ക്രമീകരണങ്ങളുടെ ഈ വിഭാഗം .പിക്ക് ഇങ്ങനെയായിരിക്കണം:

INSTALLED_APPS = [
    'feed',
]

ഞങ്ങൾ മറക്കുന്നതിന് മുമ്പ്, ജാങ്കോ പ്രവർത്തിക്കുന്നുണ്ടെന്ന് പരീക്ഷിക്കാം. Python Mancerver.py inanserver 0.0.0:8000, തുടർന്ന് ഞങ്ങൾക്ക് സെർവർ പ്രവർത്തിപ്പിച്ച് ഒരു വെബ്പേഷ്യൻ ഭാഷയിൽ നാവിഗേറ്റുചെയ്യുക, കൂടാതെ മറ്റൊരു കമാൻഡിന് സമാനമായ സെർവർ ഉപേക്ഷിക്കുക.

ഇപ്പോൾ, ചില പൈത്തൺ കോഡ് എഴുതാൻ നമുക്ക് കുഴിക്കാം. Jjango- ന് മൂന്ന് പ്രധാന ഘടകങ്ങളുണ്ട്, അവയെല്ലാം കോഡ് പൂർണ്ണമായും പ്രവർത്തിപ്പിക്കുന്നു. ഉപയോക്താവിനെ ഉപയോക്താവിനെ വിളിക്കുന്നതിന് മുമ്പ് മോഡൽ, കാഴ്ച, ടെംപ്ലേറ്റ് എന്നിവ എന്ന് വിളിക്കുന്നു.

വീണ്ടെടുക്കൽ, നോട്ടം, റെൻഡറിംഗ് എന്നിവയ്ക്കായി ഡാറ്റാബേസിൽ വിവരങ്ങൾ സൂക്ഷിക്കുന്ന കോഡാണ് മോഡൽ.

മോഡൽ എങ്ങനെ റെൻഡർ ചെയ്തു, കൃത്രിമം, പരിഷ്ക്കരിച്ചുവെന്ന് കാഴ്ച തീരുമാനിക്കുന്നു, മിക്കവാറും എല്ലാ കാഴ്ചകളും നേരിട്ട് ഒരു മോഡൽ ഉപയോഗിക്കും.

ടെംപ്ലേറ്റ് ഭാഷ എന്നറിയപ്പെടുന്ന ചില അധിക ബെല്ലുകളും വിസിലുകളും ഉള്ള HTML കോഡാണ് ടെംപ്ലേറ്റ്. മോഡലുകളും വിവരങ്ങളും (യുഎസ്വാൾ സ്ട്രിംഗുകളും പൂർണ്ണസംഖ്യകളും) പോലുള്ള മോഡലുകളും വിവരങ്ങളും (ഉപയോക്തൃ വിവരങ്ങൾ) പോലുള്ള സന്ദർഭവും ടെംപ്ലേറ്റ് റെൻഡർ ചെയ്യുന്നു.

ഇജാൻഗോയ്ക്ക് മറ്റ് ഘടകങ്ങളുണ്ട്, എന്നാൽ ഇവയിൽ പരിമിതപ്പെടുത്തിയിട്ടില്ല:

ഞങ്ങൾ ചർച്ച ചെയ്തതുപോലെ അപ്ലിക്കേഷൻ ക്രമീകരിക്കുന്ന ക്രമീകരണങ്ങൾ.

വെബ് ആപ്ലിക്കേഷന്റെ നിർദ്ദിഷ്ട ഭാഗങ്ങളിലേക്ക് ആക്സസ് നേടുന്നതിന് ഉപയോക്താവ് ഇനിപ്പറയുന്നവയാണ് ഉപയോക്താവ്.

ഫോമുകൾ, സെർവറിലേക്ക് അയച്ച വിവരങ്ങൾ എത്രമാത്രം കൈകാര്യം ചെയ്യുകയും ഡാറ്റാബേസിനും ഉപയോക്താവിനും റെൻഡർ ചെയ്യുകയും ചെയ്യുന്നു. ഇവ സെർവർ ഭാഗത്തെ പ്രോസസ്സ് ചെയ്യുന്നതിന്റെ അടിസ്ഥാനമാണ്, മാത്രമല്ല കമ്പ്യൂട്ടർ സ്റ്റോറുകളും, പ്രത്യേകിച്ച് ടെക്സ്റ്റ് സ്ട്രിംഗുകൾ, അക്കങ്ങൾ, ട്രൂ / തെറ്റായ ബൂളിയറുകൾ (സാധാരണയായി ചെക്ക്ബോക്സുകൾ) സ്വീകരിക്കാൻ കഴിയും.

ടെംപ്ലേറ്റുകൾ, ഏത് HTML കോഡും HTML-യും തമ്മിലുള്ള വിടവ്, അതായത് ബാഹുന്ദ് ആക്സസ് ഉപയോഗിച്ച് ഒരു വെബ്സൈറ്റ് ആയി നൽകാൻ കഴിയും, അതേസമയം, ഒരു വെബ്സൈറ്റ് ഉപയോഗിക്കാൻ കഴിയും, അതേസമയം, ഒരു വെബ്സൈറ്റ് ഉപയോഗിക്കാൻ കഴിയും, അതേസമയം, ഒരു വെബ്സൈറ്റ് സുരക്ഷിതമാക്കും, കൂടാതെ സെർവറിന് സമീപം ആവശ്യമില്ല

സാധാരണ ഫയലുകൾ, സാധാരണയായി ജാവാസ്ക്രിപ്റ്റ്, സെർവർ സേവിക്കുന്ന ലൈബ്രറികൾ, ടെംപ്ലേറ്റ് ഉപയോഗിച്ച് ലിങ്കുചെയ്തിരിക്കുന്ന ലൈബ്രറികളാണ്.

സെർവർ സേവനമനുഷ്ഠിക്കുന്ന അല്ലെങ്കിൽ ബാഹ്യമായി ഹോസ്റ്റുചെയ്യുന്നതിനോ അല്ലെങ്കിൽ ഹോസ്റ്റിംഗിനായി മറ്റൊരു സെർവറിലേക്ക് (ഒരു ബക്കറ്റ്) ലേക്ക് എഴുതുകയും ചെയ്ത മീഡിയ ഫയലുകൾ സെർവറിലേക്ക് എഴുതി.

മധ്യവെയർ, ഇത് എല്ലാ കാഴ്ചപ്പാടും പോലെ പ്രവർത്തിക്കുന്നതും കാഴ്ചയിൽ "ഉൾപ്പെടുത്തി" എന്ന് കണക്കാക്കപ്പെടുന്ന കോഡുകളുടെ കഷണങ്ങളാണ്.

സന്ദർഭ പ്രോസസ്സറുകൾ, ഓരോ കാഴ്ചയുടെയും സന്ദർഭം പ്രകടിപ്പിച്ച് അധിക സന്ദർഭം ചേർക്കാൻ ഉപയോഗിക്കുന്നു.

കാഴ്ച റെൻഡർ ചെയ്യുന്നതിന് മുമ്പ് ഉപയോക്താവോ അഭ്യർത്ഥന ചില ആവശ്യകതകൾ കൈമാറുന്നുവെന്ന് ടെസ്റ്റുകൾ.

ഉപഭോക്താക്കൾ, വെബ്സൈറ്റുകൾ എങ്ങനെ കൈകാര്യം ചെയ്യുകയും ആശയവിനിമയത്തോട് പ്രതികരിക്കുകയും ചെയ്യുന്നു.

മോഡലുകൾ രജിസ്റ്റർ ചെയ്യാൻ ഉപയോഗിക്കുന്ന അഡ്മിനും, അതിനാൽ ഒരു ഗ്രാഫിക്കൽ ഇന്റർഫേസിലൂടെ ഡാറ്റാബേസ് നൽകാമെന്ന ഡാറ്റാബേസോ അഡ്മിൻ പേജിൽ അവ വിശദമായി മനസിലാക്കാൻ കഴിയും.

സെലറി, അസിൻക്രണസ് ടാസ്ക്കുകൾ നിർവചിക്കുന്നു

ഡാങ്കോയ്ക്ക് മറ്റ് നിരവധി ഘടകങ്ങൾ ഉണ്ടായിരിക്കാം, അത് ഇവിടെ വിശദമായി ചർച്ച ചെയ്യും. ഫാംഗോ കൂടുതൽ പ്രവർത്തനക്ഷമമാക്കുന്നതിന് ധാരാളം മാർഗങ്ങളുണ്ട്, അവ ഏറ്റവും വേഗതയുള്ളതും സ്ട്രീംലൈഡ് കമ്മ്യൂണിക്കേഷൻ ചാനലുകളും ചേർക്കുന്നു, ഇത് അസിൻക്രണസ്ലൈഡ് കമ്മ്യൂണിക്കേഷൻ ചാനലുകളാണ്, അത് ദെദ്യോൺലൈൻഡ് കമ്മ്യൂണിക്കേഷൻ ചാനലുകൾ, പ്രത്യേകിച്ച്, പ്രത്യേകിച്ച്, പ്രത്യേകിച്ച്, മിക്ക കോഡലും നടപ്പിലാക്കുന്ന ഫംഗകങ്ങൾ. കാഴ്ചകൾ പ്രധാനമാണ്, കാരണം അവ സാധാരണയായി ഒരു നിർദ്ദിഷ്ട URL പാറ്റേൺ അല്ലെങ്കിൽ ഒരു നിർദ്ദിഷ്ട വിഭാഗം അല്ലെങ്കിൽ സെർവറിന്റെ ഒരു വിഭാഗം പ്രഖ്യാപിക്കുന്നു.

ആദ്യം, നമുക്ക് കാഴ്ചകൾ പരിശോധിക്കാം. കാഴ്ചയിൽ ഉപയോഗിക്കുന്ന കോഡ് സൂചിപ്പിക്കുന്നത് കാഴ്ചകൾ കാണുക, അവ പതിവ് ഫംഗ്ഷൻ നിർവചനങ്ങൾ അല്ലെങ്കിൽ ക്ലാസുകൾ ഉപയോഗിച്ച് നിർവചിക്കപ്പെടുന്നു. ലളിതമായ കാഴ്ചകൾ ഫംഗ്ഷൻ ഡെഫനിഷൻ ഡിഫിലൂടെ നിർവചിക്കുകയും ഒരു അടിസ്ഥാന ടെംപ്ലേറ്റ് ഉപയോഗിച്ച് ഒരു httprespose തിരികെ നൽകുകയും ചെയ്യുന്നു. "ഹലോ വേൾഡ്" എന്ന വാചകം തിരികെ നൽകുന്നതിന് ഒരു അടിസ്ഥാന കാഴ്ച നിർവചിച്ചുകൊണ്ട് നമുക്ക് ആരംഭിക്കാം. നിങ്ങൾ ഡെഫ്, അതേസമയം, തുടങ്ങിയ പ്രസ്താവനയ്ക്ക് ശേഷം കോഡ് ചേർക്കുമ്പോൾ, നിങ്ങളുടെ പ്രവർത്തനത്തിന് അപേക്ഷിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്ന ഓരോ നിർവചനങ്ങളും നിങ്ങൾ 4 ഇടങ്ങൾ ചേർക്കേണ്ടതുണ്ട്. ഇവയിൽ ഓരോതും ഉടൻ ഞങ്ങൾ ഉടൻ ലഭിക്കും.

ഞങ്ങളുടെ സൈറ്റിന്റെ ഡയറക്ടറിയിൽ നിന്ന്, നാനോ ഉപയോഗിച്ച് ഫീഡ് / വ്യൂസ്.പി ഫയൽ എഡിറ്റുചെയ്ത് ഫയലിന്റെ അവസാനത്തിൽ ഇനിപ്പറയുന്ന വരികൾ ചേർക്കുക.

from django.http import HttpResponse

def hello(request):
    return HttpResponse('hello world')

ഓപ്പണിംഗ്, ക്ലോസിംഗ് എന്നിവ ഉപയോഗിച്ച് സൂചിപ്പിച്ചിരിക്കുന്ന ഒരു ടെക്സ്റ്റ് സ്ട്രിംഗ് ഉപയോഗിച്ച് Django- ന്റെ httprpsoss പ്രതികരിക്കുന്നു '. നിങ്ങൾ ഒരു ഫംഗ്ഷനോ അല്ലെങ്കിൽ ക്ലാസിലോ ഉള്ള വിവരങ്ങൾ അല്ലെങ്കിൽ ഒരു സ്ട്രിംഗ് പോലുള്ള വിവരങ്ങൾ കൈമാറുമ്പോഴെല്ലാം, നിങ്ങൾ പരാൻതീസിസ് ഉപയോഗിക്കേണ്ടതുണ്ട് (, തുറന്ന് അടയ്ക്കുന്നത്).

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

അപ്ലിക്കേഷനിൽ / urls.py, ഇറക്കുമതി ചെയ്ത ശേഷം ഇറക്കുമതി ചെയ്ത ശേഷം ഒരു വരി ചേർക്കുക, ഞങ്ങൾ സൃഷ്ടിച്ച കാഴ്ച ഇറക്കുമതി ചെയ്യുന്നതിന് ശേഷം ഒരു വരി ചേർക്കുക.

from feed import views as feed_views

ഇപ്പോൾ, കാഴ്ച പാറ്റേൺ നിർവചിക്കാം. കാഴ്ച പാറ്റേണുകൾക്ക് മൂന്ന് ഘടകങ്ങളുണ്ട്, ഇത് വെബ്പേജിനുള്ളിൽ കാണുന്നതിന് നാവിഗേഷൻ ബാറിലേക്ക് (ഉപയോക്തൃ തരം) ഒരു ടെംപ്ലേറ്റിൽ പ്രവർത്തിക്കുമ്പോൾ, പ്രത്യേകിച്ച് ഒരു സ friendly ഹാർദ്ദപരമായ നാമം, പ്രത്യേകിച്ച് കൂടുതൽ യുക്തിസഹമായ പേര് എടുക്കാൻ കഴിയും. ഈ രീതിയിൽ കാര്യങ്ങൾ ചെയ്യുകയും വഴങ്ങുകയും ചെയ്യുമെന്ന് അർത്ഥമുണ്ട്, കാരണം നിങ്ങളുടെ കോഡ്ബേസ് ഒരു വലിയ മാറുന്ന പരിതസ്ഥിതിയും മൂല്യവത്തായതും ജോലി ചെയ്യാൻ എളുപ്പവുമാണ്. നിങ്ങളുടെ കാഴ്ച എങ്ങനെയായിരിക്കുമെന്ന് ഇതാ, നിങ്ങൾക്ക് ഇത് URLPATTRESS = [അപ്ലിക്കേഷന്റെ / urls.py. മുകളിൽ വിവരിച്ച മൂന്ന് ഘടകങ്ങളും പാത്ത് എന്ന് വിളിക്കുന്ന ഒരു ഫംഗ്ഷനുകളുമായി കാഴ്ച പാറ്റേൺ നിർവചിക്കപ്പെടുന്നു. നിങ്ങളുടെ URL പാറ്റേണുകൾ ഒരു ലിസ്റ്റാണ്, അതിനാൽ അവയിൽ ഓരോ ഇനവും കോമ ഉപയോഗിച്ച് അവസാനിപ്പിക്കുന്നത് ഉറപ്പാക്കുക, കാരണം ഇത് ഓരോരുത്തർക്കും വേർതിരിക്കുന്നു. Ontation.py പോലുള്ള ഒരു പുതിയ ലൈനിൽ ഓരോ ഇനത്തിലും ഒരു പുതിയ വരിയിൽ പോകണം. വെബ് സെർവറിന്റെ റൂട്ട് ഡയറക്ടറിയിൽ പ്രവർത്തിക്കുന്ന ഒരു കാഴ്ച സൃഷ്ടിക്കുന്നതിന് ഒരു ശൂന്യമായ സ്ട്രിംഗ് ഫംഗ്ഷനുമായി ഞങ്ങൾ കാഴ്ചയുടെ ആദ്യ ഘടകം നിർവചിക്കും. നിങ്ങളുടെ URLS.PY ഇപ്പോൾ ഇതുപോലെയായിരിക്കണം:

from feed import views as feed_views

urlpatterns = [
    path('', feed_views.hello, name='hello'),
]

പൂർണ്ണമായും സ്റ്റാംഗോ ഉപയോഗിച്ച് ഒരു വെബ്സൈറ്റ് സൃഷ്ടിക്കുന്നതിനുള്ള അടിസ്ഥാനം ഇതാണ്. കൂടുതൽ ചലനാത്മക വെബ്സൈറ്റ് നടത്തുന്നതിന്, ചിത്രങ്ങൾ, വീഡിയോകൾ, ഓഡിയോ എന്നിവയും അതിലേറെയും പോലുള്ള വിവരങ്ങൾ ആരംഭിക്കാൻ നമുക്ക് കഴിയും, ഞങ്ങൾ മോഡലുകൾ ഉപയോഗിക്കേണ്ടതുണ്ട്, അത് ഞങ്ങൾ അടുത്തതായി പര്യവേക്ഷണം ചെയ്യും. ഇപ്പോൾ, ഞങ്ങളുടെ കോഡ് പരിശോധിച്ച് സെർവർ പ്രവർത്തിപ്പിക്കാം. പിശകുകൾക്കായി കോഡ് പരിശോധിക്കുന്നതിന്, പ്രവർത്തിപ്പിക്കുക:

python manage.py check

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

python manage.py runserver 0.0.0.0:8000

ഇപ്പോൾ ഒരു വെബ് ബ്ര browser സർ തുറന്ന് http: // ലോക്കൽഹോസ്റ്റ്: 8000 ലേക്ക് നാവിഗേറ്റുചെയ്യുക. നിങ്ങളുടെ കാഴ്ചയിലെ പരാൻതീസിസിലും എച്ച്ടിടിവർസ്പെൻസുകളുടെ പ്രവർത്തനത്തിലും നൽകിയ വാചകം നിങ്ങൾ കാണും. ഇത് ഒരു അടിസ്ഥാന ഉദാഹരണമാണ്, പക്ഷേ നിങ്ങൾ ഇത് വളരെ ദൂരെയുള്ളതാണെങ്കിൽ, ലിനക്സ്, ബാഷ്, പൈത്തൺ, ജാങ്കോ ജോലികൾ എന്നിവയുടെ അടിസ്ഥാനകാര്യങ്ങൾ നിങ്ങൾ മനസ്സിലാക്കുന്നു. നമുക്ക് ചില ഡാറ്റാബേസ് മോഡലിംഗിലേക്ക് ആഴത്തിൽ കുഴിക്കാം, വിവരങ്ങൾ സംഭരിക്കുന്നതിന് ഒരു പൈത്തൺ ക്ലാസിന്റെ ശക്തി പര്യവേക്ഷണം ചെയ്യുകയും ചെയ്യാം. അപ്പോൾ, ഞങ്ങളുടെ സൈറ്റിനെ പൂർണ്ണമായി ഫീച്ചർ ചെയ്യുന്നതിന് മുമ്പ്, ഞങ്ങളുടെ സൈറ്റിന് ഒരു പിടി ലഭിക്കാൻ തുടങ്ങും, മുമ്പ്, വഴക്കമുള്ളതും ജാവാസ്ക്രിപ്റ്റും മെഷീൻ പഠനവും ഉപയോഗിച്ച് സുരക്ഷിതവും സുരക്ഷിതവുമാക്കുന്നതിന് ഞങ്ങൾ ഒരു പിടി ലഭിക്കും.

നിങ്ങളുടെ അപ്ലിക്കേഷന്റെ Sodels.py- ൽ ക്ലാസുകൾ സൂക്ഷിക്കുന്നു. നാനോ ഉപയോഗിച്ച് അപ്ലിക്കേഷൻ / മോഡലുകൾ എഡിറ്റുചെയ്യുക, ഒരു പുതിയ ക്ലാസ് ചേർക്കുക. ക്ലാസ് നിർവചനത്തിൽ ഒരു ക്ലാസ് നിർവചിക്കപ്പെട്ടിട്ടുണ്ട്, ഈ സാഹചര്യത്തിൽ നിന്ന് അതിന് പാരമ്പര്യമായി പാസാകുന്നു, ഈ സാഹചര്യത്തിൽ നിന്ന് മോഡൽ .മോഡൽ. ക്ലാസ് നിർവചനത്തിന് ശേഷവും ക്ലാസ് നിർവചനത്തിന് ശേഷമാണ് ക്ലാസിന്റെ പേര്. ഞങ്ങളുടെ ക്ലാസിന് ഇത് വീണ്ടെടുക്കാനും അത് അദ്വിതീയമായി സൂക്ഷിക്കാനും കഴിയുന്ന ഒരു ഐഡി ആവശ്യമാണ്, മാത്രമല്ല ചില വിവരങ്ങൾ സംഭരിക്കാൻ ഇതിന് ഒരു ടെക്സ്റ്റ് ഫീൽഡും ആവശ്യമാണ്. പിന്നീട് ഞങ്ങൾക്ക് ഒരു ടൈംസ്റ്റാമ്പ്, ഫയലുകൾ, ബൂലിയൻസ് എന്നിവ ചേർക്കാം (ക്രമീകരിക്കാൻ സഹായിക്കുന്നതും അത് സെർവറിലേക്ക് പ്രവേശിക്കാൻ സഹായിക്കുന്നതും അതിലേറെയും ചേർക്കാൻ കഴിയും. ചുവടെ കോഡ് അൺപാക്ക് ചെയ്യാം:

from django.db import models # ഞങ്ങളുടെ ക്ലാസ് നിർവചിക്കാൻ ഉപയോഗിക്കുന്ന ഇറക്കുമതി, അത് ആട്രിബ്യൂട്ടുകൾ
class Post(models.Model): # നമ്മുടെ ക്ലാസിന്റെ നിർവചനം
    id = models.AutoField(primary_key=True) # മോഡലിനെ അന്വേഷിക്കാൻ അനുവദിക്കുന്ന ഞങ്ങളുടെ മോഡലിന്റെ ഐഡി യാന്ത്രികമായി സൃഷ്ടിക്കുക, അത് അദ്വിതീയമായി സൂക്ഷിക്കുക, അത് സൃഷ്ടിച്ചുകഴിഞ്ഞാൽ മാറ്റിയുമായി സംവദിക്കേണ്ടതുണ്ട്.
    text = models.TextField(default='') # ആട്രിബ്യൂട്ട് ഞങ്ങളുടെ ക്ലാസ് സ്റ്റോറുകൾ, ഈ സാഹചര്യത്തിൽ, ഒരു ശൂന്യമായ സ്ട്രിംഗിലേക്ക് ഒരു നിശ്ചിത വാചകം.

പൂർത്തിയാക്കാൻ മുമ്പ് ഫയൽ അടച്ച് സംരക്ഷിക്കുക.

ഞങ്ങളുടെ അപ്ലിക്കേഷൻ വികസിക്കുമ്പോൾ ഞങ്ങൾ ഈ ക്ലാസ് അപ്ഡേറ്റ് ചെയ്യുമ്പോൾ മറ്റ് നിരവധി ഫീൽഡുകളും ഓപ്ഷനുകളും ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും, പക്ഷേ കുറച്ച് വാചകം പോസ്റ്റുചെയ്യുന്നതിന് ഒരു അപ്ലിക്കേഷൻ സൃഷ്ടിക്കുന്നതിനുള്ള അടിസ്ഥാന ആവശ്യങ്ങൾ ഇതാണ്. എന്നിരുന്നാലും, ഈ മോഡൽ ഒറ്റയ്ക്ക് പ്രവർത്തിക്കില്ല. മുമ്പ് വിവരിച്ചതുപോലെ, ഈ മോഡൽ ജോലി ചെയ്യാൻ ഞങ്ങൾക്ക് ഒരു ഇഷ്ടാനുസൃത കാഴ്ചയും ഇഷ്ടാനുസൃത URL പാറ്റേണും ആവശ്യമാണ്, ഒരു ടെംപ്ലേറ്റിനൊപ്പം ഒരു ഫോം ആവശ്യമാണ്. ആദ്യം ഫോം പര്യവേക്ഷണം ചെയ്യാം.

ഒരു ഫോം നിർവചിക്കാൻ, അപ്ലിക്കേഷൻ / ഫോം എഡിറ്റുചെയ്യുക നാനോ ഉപയോഗിച്ച് പി എഡിറ്റ് ചെയ്ത് ഇനിപ്പറയുന്ന വരികൾ ചേർക്കുക. ഞങ്ങൾക്ക് രണ്ട് ഇറക്കുമതി ആവശ്യമാണ്, ഞങ്ങളുടെ ഫോംസ് ക്ലാസ്, അതുപോലെ തന്നെ ഞങ്ങൾ സൃഷ്ടിച്ച മാതൃകയും, മോഡലിന് സമാനമായ ഒരു തരം നിർവചനം, ഫോം സംവദിക്കുന്ന മാതൃക നിർവചിക്കുന്ന മെറ്റായെ നിർവചിക്കും. ഫോമിന് ഒരു സമാരംഭിക്കൽ ഫംഗ്ഷൻ ഉണ്ടായിരിക്കാം, അത് അഭ്യർത്ഥന, മോഡൽ അല്ലെങ്കിൽ അല്ലാത്തപക്ഷം, ഞങ്ങൾ പിന്നീട് പര്യവേക്ഷണം ചെയ്യും.

മോഡൽ ഫോമുകൾ വളരെ ഉപയോഗപ്രദമാണ്, കാരണം അവർക്ക് ഒരു മോഡൽ സൃഷ്ടിക്കാനോ ഒരു മോഡൽ എഡിറ്റുചെയ്യാനും കഴിയും, അതിനാൽ ഞങ്ങൾ അവ രണ്ടും ഉപയോഗിക്കും. നമുക്ക് ചുവടെയുള്ള ഫോമുകൾ നിർവചിക്കാം.

from django import forms
from feed.models import Post

class PostForm(forms.ModelForm):
    text = forms.CharField(widget=forms.Textarea)
    class Meta:
        model = Post
        fields = ('text',)

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

python manage.py makemigrations
python manage.py migrate

ഇത് എക്സിക്യൂട്ട് ചെയ്യാൻ ഒരു മിനിറ്റ് എടുക്കും, പക്ഷേ അത് ചെയ്യുമ്പോൾ, സോഫ്റ്റ്വെയറിൽ മോഡൽ ആക്സസ് ചെയ്യാൻ ഇത് നിങ്ങളെ അനുവദിക്കും. ഞങ്ങളുടെ മോഡൽ എവിടെ കാണാനാകുമെന്ന് ഒരു കാഴ്ചപ്പാടാക്കി നമുക്ക് തുടരാം. ഫീഡ് / views.py എഡിറ്റുചെയ്യുക, അറിയിച്ചതുപോലെ ഇനിപ്പറയുന്ന കോഡ് ചേർക്കുക. # ചിഹ്നത്തിനുശേഷം നിങ്ങൾ ഒന്നും ചേർക്കേണ്ടതില്ല, കോഡിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ സൂചിപ്പിക്കാൻ ഉപയോഗിക്കുന്ന അഭിപ്രായങ്ങളാണ് ആ കോഡ്. കാഴ്ചകളിൽ ഞങ്ങളുടെ മോഡൽ ഇറക്കുമതി ചെയ്യുന്നതിലൂടെ ഞങ്ങൾ ആരംഭിക്കും, മാത്രമല്ല ഇത് ഡിസ്പ്ലേയ്ക്കായുള്ള ഒരു ടെംപ്ലേറ്റിൽ ഒരു ടെംപ്ലേറ്റിൽ ഇത് റെൻഡർ ചെയ്യാവുന്ന ഒരു സന്ദർഭത്തിലേക്ക് ചേർക്കുന്നു. അടുത്തതായി, മോഡലിനെ അടിസ്ഥാനമാക്കി ഒരു പുതിയ ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുന്നതിനും സെർവറിലേക്ക് പോസ്റ്റുചെയ്യുന്നതിനും ഫോം, മോഡൽ എന്നിവ ഒരു ബട്ടൺ ഉപയോഗിച്ച് ഞങ്ങൾ ഒരു ടെംപ്ലേറ്റ് ചേർക്കും. ഇത് സങ്കീർണ്ണമാണെന്ന് തോന്നുന്നു, അതിനാൽ നമുക്ക് അത് ഘട്ടം ഘട്ടമായി എടുക്കാം. ഞങ്ങൾ കാഴ്ച പൂർത്തിയാക്കുന്നതിന് മുമ്പ്, മോഡൽ റെൻഡർ ചെയ്യുന്ന ഒരു ടെംപ്ലേറ്റ് സൃഷ്ടിക്കാം, ഷെല്ലിൽ ഒരു പുതിയ പോസ്റ്റ് സൃഷ്ടിച്ചുകൊണ്ട് നമുക്ക് അത് കാണാൻ കഴിയുമെന്ന് ഉറപ്പാക്കാം. ആ കാഴ്ച എങ്ങനെ കാണണമെന്ന് ഇതാ:

    posts = Post.objects.all() # ഡാറ്റാബേസിലെ എല്ലാ പോസ്റ്റുകളും ഇതുവരെ അന്വേഷിക്കുക

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

ടെംപ്ലേറ്റുകൾ സൃഷ്ടിക്കാൻ ആരംഭിക്കുന്നതിന്, ഫീഡിൽ രണ്ട് ഡയറക്ടറികൾ ഉണ്ടാക്കുക.

mkdir feed/templates
mkdir feed/templates/feed

അടുത്തതായി, മുകളിലുള്ള ഡയറക്ടറിയിൽ ഒരു ടെംപ്ലേറ്റ് എഡിറ്റുചെയ്യുക, തീറ്റ / ടെംപ്ലേറ്റുകൾ / ഫീഡ്, ഈ ഉദാഹരണത്തിനായി കോഡ് ചേർക്കുക. ഈ ഉദാഹരണത്തിന് ടെംപ്ലേറ്റ് നോക്കാം.

ഇതൊരു ലളിതമായ ടെംപ്ലേറ്റാണ്. ഇത് പ്രാരംഭവും അടയ്ക്കുന്ന HTML ടാഗുകളും, ഒരു പ്രമാണ തരം ടാഗ്, ഒരു ലെജന്റ് ശീർഷകമുള്ള ഒരു ബോഡി ടാഗ്, ഒരു ബ്രേക്ക് ടാഗ്, ടെംപ്ലേറ്റിലെ ഒരു ഖണ്ഡികയായി പോസ്റ്റുകളുടെ പട്ടികയിലെ ഓരോ പോസ്റ്റിലും ഒരു ബ്രേക്ക് ടാഗ്. പോസ്റ്റുകൾ റെൻഡർ ചെയ്യാൻ എടുക്കുന്നതെല്ലാം ഇതാണ്, പക്ഷേ ഇതുവരെ ഡാറ്റാബേസിൽ ആരുമില്ല. ഷെൽ ഉപയോഗിച്ച് ചിലത് സൃഷ്ടിക്കാം. മാനേജുമായി ഞങ്ങൾക്ക് ഷെൽ ഓടിക്കാൻ കഴിയും

python manage.py shell

ഇപ്പോൾ, ഞങ്ങളുടെ പോസ്റ്റ് മോഡൽ ഇറക്കുമതി ചെയ്യാം

from feed.models import Post

അടുത്തതായി, ഞങ്ങൾ ഒരു സ്ട്രിംഗ് ഉപയോഗിച്ച് ഒരു ലളിതമായ പോസ്റ്റ് സൃഷ്ടിക്കുകയും ഷെല്ലിൽ നിന്ന് പുറത്തുകടക്കുകയും ചെയ്യും. സാധുവായ വാചകം പോലെ സ്ട്രിംഗ് എന്തും ആകാം.

Post.objects.create(text='hello world')
exit()

അവസാനമായി, ഞങ്ങളുടെ ഫീഡിലേക്ക് ഞങ്ങൾ ഒരു URL പാറ്റേൺ ചേർക്കേണ്ടതുണ്ട്. ഞങ്ങളുടെ ഫീഡ് അപ്ലിക്കേഷൻ ഒന്നിലധികം URL- കൾ ഉപയോഗിക്കുകയും ഫയൽ വലുപ്പങ്ങൾ ചെറുതായി സൂക്ഷിക്കുകയും ചെയ്യും, ഇത് ഞങ്ങളുടെ ഫീഡ് അപ്ലിക്കേഷനിൽ ഒരു പ്രാദേശിക URLS.py സൃഷ്ടിക്കാം:

from django.urls import path
from . import views

urlpatterns = [
    path('', views.feed, name='feed'),
]

ഞങ്ങൾ ഇതിനെ വിളിക്കാൻ തീരുമാനിച്ച ഏത് അടിസ്ഥാന അപ്ലിക്കേഷനിൽ ഞങ്ങൾ URLS.പി എഡിറ്റുചെയ്യേണ്ടതുണ്ട്, ഇത് ഞങ്ങൾ സൃഷ്ടിച്ച ആദ്യ ഡയറക്ടറിയായിരുന്നു. അപ്ലിക്കേഷൻ / App.py എഡിറ്റുചെയ്യുക, കൂടാതെ URL പാറ്റേണുകളിലേക്ക് ഇനിപ്പറയുന്നവ ചേർക്കുക

from django.urls import include # മുകളിൽ
    # ... മുമ്പത്തെ കോഡ് ഇവിടെ

ഇപ്പോൾ, ഞങ്ങൾ പൈത്തൺ മാനേജുമായി പ്രവർത്തിക്കുമ്പോൾ, ഞങ്ങൾ സൃഷ്ടിച്ച പേജ് ഡാറ്റാബേസിലെ ഇനങ്ങൾക്കൊപ്പം ഞങ്ങൾ സൃഷ്ടിച്ച പേജ് ഞങ്ങൾ കാണും. അടുത്തതായി, ഞങ്ങൾ സൃഷ്ടിച്ച ഫോം നടപ്പിലാക്കുകയും ഞങ്ങളുടെ സ്വന്തം പോസ്റ്റുകൾ സൃഷ്ടിക്കാൻ ആരംഭിക്കുകയും ചെയ്യാം. ഞങ്ങൾ വളരെയധികം കോഡ് എഴുതുന്നതിനുമുമ്പ്, ഞങ്ങൾ നേരത്തെ എഴുതിയ സ്ക്രിപ്റ്റ് ഉപയോഗിച്ച് ഒരു ബാക്കപ്പ് ഉണ്ടാക്കാം, ബാക്കപ്പ്. ഷെല്ലിൽ ഈ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുക, കുറച്ച് നിമിഷങ്ങൾ കാത്തിരിക്കുക, കൂടാതെ എല്ലാ കോഡും ഞങ്ങളുടെ ജിറ്റ് ശേഖരണത്തിലേക്ക് ബാക്കപ്പ് ചെയ്യും.

backup

ഫോം നടപ്പിലാക്കുന്നത് താരതമ്യേന ലളിതമാണ്. ഞങ്ങൾ ഞങ്ങളുടെ ഫോം ഇമ്പോർന്ന്, കാഴ്ചയ്ക്കായി ഒരു പോസ്റ്റ് അഭ്യർത്ഥന ഹാൻഡ്ലർ ചേർക്കുക, അതേ കാഴ്ചപ്പാടിലേക്ക് റീഡയറക്ടുചെയ്യുന്നതിന് മുമ്പ് ഡാറ്റാബേസിൽ പോസ്റ്റ് സംരക്ഷിക്കുക. ഞങ്ങൾ ഇതിനകം ഇറക്കുമതി ചെയ്ത റീഡയറക്ട് പ്രവർത്തനം ഉപയോഗിക്കാം, കാഴ്ച പാറ്റേണിനായി URL ലഭിക്കുന്നതിന് റിവേർഡ് എന്ന മറ്റൊരു ഫംഗ്ഷൻ. 'ഫീഡ്: ഫീഡ്' ഉപയോഗിച്ച് ഞങ്ങൾ ഇത് ചോദ്യം ചെയ്യും, കാരണം ഉൾപ്പെടുത്തിയ രീതിയുടെ നെയിംസ്പെയ്സ് തീറ്റയാണെന്നും ഈ കാഴ്ചയെ ഫീഡ് എന്നും വിളിക്കുന്നു.

    posts = Post.objects.all() # ഡാറ്റാബേസിലെ എല്ലാ പോസ്റ്റുകളും ഇതുവരെ അന്വേഷിക്കുക
    if request.method == 'POST': # പോസ്റ്റ് അഭ്യർത്ഥന കൈകാര്യം ചെയ്യുക
        form = PostForm(request.POST) # ഫോമിന്റെ ഒരു ഉദാഹരണം സൃഷ്ടിച്ച് അതിലേക്ക് ഡാറ്റ സംരക്ഷിക്കുക
        if form.is_valid(): # ഫോം സാധൂകരിക്കുക
            form.save() # പുതിയ ഒബ്ജക്റ്റ് സംരക്ഷിക്കുക
        return redirect(reverse('feed:feed')) # GET അഭ്യർത്ഥനയുള്ള അതേ URL- ലേക്ക് റീഡയറക്ട് ചെയ്യുക
        'form': PostForm(), # ഫോം സന്ദർഭത്തിലേക്ക് കടക്കുന്നത് ഉറപ്പാക്കുക, അതുവഴി ഞങ്ങൾക്ക് അത് നൽകാം.

ഇപ്പോൾ, പുതിയ ഫോമിനായി ഞങ്ങൾ ടെംപ്ലേറ്റ് അപ്ഡേറ്റ് ചെയ്യേണ്ടതുണ്ട്. ഉപയോഗിച്ച് നമുക്ക് ഇത് ചെയ്യാൻ കഴിയും

ഇത് തകർക്കാം. ഒരു പുതിയ ഫോം ക്ലാസ്, ഒരു ടോക്കൺ, രൂപം, ഒരു സമർപ്പിക്കൽ ബട്ടൺ ഉണ്ട്. വളരെ ലളിതമാണ്, പക്ഷേ ഞങ്ങൾ അത് പരിശോധിക്കുമ്പോൾ, അത് മികച്ചതായി കാണാൻ ഞങ്ങൾ ആഗ്രഹിച്ചേക്കാം. ഇത് പ്രവർത്തിക്കുന്നു, ഞങ്ങൾക്ക് ഫോം ഉപയോഗിച്ച് പുതിയ പോസ്റ്റുകൾ പോസ്റ്റുചെയ്യാൻ കഴിയും, അവ ഇപ്പോൾ ഡാറ്റാബേസിൽ സംരക്ഷിക്കും. ഇവിടെ കുറച്ച് കാര്യങ്ങൾ നടക്കുന്നു. പ്രമാണം ഒരു HTML പ്രമാണമാണെന്ന് പ്രഖ്യാപിക്കാൻ ഞങ്ങൾ HTML ടാഗുകൾ ഉപയോഗിക്കുന്നു, ഫോമിനായി ടോക്കൺ റെക്കൺ റെക്കൺ റെൻഡൻ റെൻഡനെ ഉപയോഗിക്കുന്നതിന്, ഫോം റെൻഡർ ചെയ്യുന്നതിന് {{...}}. ബ്ലോക്ക് ടാഗുകളും ടെംപ്ലേറ്റ് ടാഗും ഉപയോഗിച്ച് വാചകം റെൻഡർ ചെയ്യുന്നതിന് ഞങ്ങൾക്ക് ഒരു ലൂപ്പ് ഉണ്ട്. ബ്ലോക്ക് ടാഗുകൾ ശരിക്കും പ്രധാനമാണ്, കാരണം ടെംപ്ലേറ്റിലെ വിഭാഗങ്ങൾ അവരുമായി എങ്ങനെ റെൻഡർ ചെയ്യുന്നുവെന്ന് നമുക്ക് നിർവചിക്കാം, കൂടാതെ ഞങ്ങൾ എങ്ങനെ വേരിയബിളുകൾ ഞങ്ങളുടെ കോഡിലേക്ക് ഇടാം

ഇപ്പോൾ നമ്മൾ ഞങ്ങളുടെ അപ്ലിക്കേഷൻ മികച്ചതായി മാറേണ്ടതുണ്ട്, കാരണം ഇപ്പോൾ ഇത് അടിസ്ഥാനപരമായി തോന്നുന്നു. സിഎസ്എസ്, ഇൻലൈൻ, അല്ലെങ്കിൽ ഓരോ ഒബ്ജക്റ്റുകളിലോ ബന്ധിപ്പിച്ച ക്ലാസുകളിലോ ഞങ്ങൾക്ക് ഇത് ചെയ്യാൻ കഴിയും. സിഎസ്എസ് ശരിക്കും നല്ലതാണ്, കാരണം അത് എങ്ങനെയാണ് കാണേണ്ടതെന്ന് പേജിലെ എല്ലാം പറയുന്നത്, അത് നന്നായി കാണപ്പെടും. ഇത് ചെയ്യാൻ കഴിയുന്ന കുറച്ച് ലൈബ്രറികളുണ്ട്, പക്ഷേ എന്റെ വ്യക്തിഗത ഗോ ബൂട്ട്സ്ട്രാപ്പ്.

അവരുടെ വെബ്സൈറ്റിൽ നിന്ന് ബൂട്ട്സ്ട്രാപ്പ് ഡ download ൺലോഡ് ചെയ്യാൻ കഴിയും,getboretstrap.com/. ഒരിക്കൽ അവിടെ ഒരിക്കൽ, ഇൻസ്റ്റാളേഷൻ ഡോക്സ് വായിക്കാൻ ബട്ടൺ അമർത്തി സിഡിഎൻ വിഭാഗം വഴിയുള്ള കോഡ് പകർത്തുക. നിങ്ങളുടെ HTML പ്രമാണത്തിന്റെ മുകളിൽ, ഹെഡ് എന്ന് വിളിക്കപ്പെടുന്ന ടാഗിൽ നിങ്ങൾക്ക് ഈ കോഡ് ആവശ്യമാണ്. കൂടാതെ, നമുക്ക് മുന്നോട്ട് പോയി ഒരു അടിസ്ഥാന ടെംപ്ലേറ്റ് സൃഷ്ടിക്കുക, അതിനാൽ ഓരോ ടെംപ്ലേറ്റിലും ഈ ലിങ്കുകൾ പുന ate സൃഷ്ടിക്കേണ്ടതില്ല.

Mkdir ടെംപ്ലേറ്റുകളുള്ള ടെംപ്ലേറ്റുകൾ എന്ന് വിളിക്കുന്ന ഒരു പുതിയ ഡയറക്ടറി നിർമ്മിക്കുക, തുടർന്ന് ടെംപ്ലേറ്റുകൾ / ബേസ്എംഎൽ എഡിറ്റുചെയ്യുക.

ഇത് ഇങ്ങനെയായിരിക്കണം:

CSS, JavaScript, .css, .js ഫയലുകൾ എന്നിവ പകർത്തുന്നുവെന്ന് ഉറപ്പാക്കുക, കാരണം ഭാവിയിൽ ഞങ്ങളുടെ സൈറ്റിനെ കൂടുതൽ പ്രവർത്തനക്ഷമമാക്കുന്നതിന് ഞങ്ങൾക്ക് ജാവാസ്ക്രിപ്റ്റ് ആവശ്യമാണ്.

ഇപ്പോൾ, നമുക്ക് ബാഷ് ഷെല്ലിലേക്ക് മടങ്ങാം, ഒരു ദ്രുത കമാൻഡ് പ്രവർത്തിപ്പിക്കാം. ഓർമ്മിക്കുക, നിങ്ങൾ എപ്പോഴെങ്കിലും വെർച്വൽ പരിസ്ഥിതി ആക്സസ് ചെയ്യേണ്ടതുണ്ടെങ്കിൽ, ഉറവിടം venv / bin / സജീവമാക്കുക. ജാങ്കോൺ പാക്കേജുകൾ പ്രാദേശികമായി തിരഞ്ഞെടുക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കും. ഞങ്ങളുടെ ഫോമുകൾ ജനറേറ്റുചെയ്ത ഫോമുകൾ നൽകുന്നതിന്, ഞങ്ങൾ ക്രിസ്പി രൂപങ്ങൾ എന്നറിയപ്പെടുന്ന ഒരു പൈത്തൺ പാക്കേജ് ഉപയോഗിക്കും. ഇനിപ്പറയുന്ന കമാൻഡ് ഉപയോഗിച്ച് ഞങ്ങൾക്ക് ഇത് ഡ download ൺലോഡ് ചെയ്യാൻ കഴിയും

pip install django-crispy-forms

ഇത് ഇൻസ്റ്റാൾ ചെയ്തുകഴിഞ്ഞാൽ, ഇത് ക്രമീകരണങ്ങൾ.

    # ... മുമ്പത്തെ കോഡ് ഇവിടെ

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

മനോഹരമാണ്! അത് ഇതിനകം തന്നെ ഒരു ചെറിയ കോഡ് ആണ്. അടുത്തതായി, എല്ലാം നന്നായി തോന്നുന്നുവെന്ന് ഉറപ്പാക്കാനും എല്ലാം ശരിയായി പ്രവർത്തിക്കുന്നുണ്ടെന്നും നമുക്ക് കാണാൻ കഴിയുമെന്ന് ഉറപ്പാക്കണം. മുമ്പത്തെ നിർദ്ദേശങ്ങൾ അനുസരിച്ച് സെർവർ പ്രവർത്തിപ്പിച്ച് സൈറ്റ് പരിശോധിച്ച് പ്രവർത്തിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കുക. മികച്ച ജോലി! അടുത്ത ഘട്ടത്തിലേക്ക് പോകാൻ നിങ്ങൾ തയ്യാറാണ്, അതിൽ സമാന URL- കൾ, ഫോമുകൾ, കാഴ്ചകൾ, ടെംപ്ലേറ്റുകൾ എന്നിവ ഉപയോഗിച്ച് ഞങ്ങൾ ഉപയോക്തൃ ലോഗിൻ പ്രവർത്തനം ചേർക്കും. അടിസ്ഥാന ടെംപ്ലേറ്റ് പ്രധാനമാണ്, ഞങ്ങൾ അത് പരിഷ്ക്കരിക്കുകയും ആവശ്യാനുസരണം ഞങ്ങളുടെ സൈറ്റിനെ കൂടുതൽ സുരക്ഷിതമാക്കുകയും ചെയ്യും, മാത്രമല്ല നിങ്ങളുടെ അപ്ലിക്കേഷൻ സുരക്ഷിതമാക്കാൻ സഹായിക്കുന്നതും നിങ്ങളുടെ സ്വന്തം അക്ക account ണ്ട് ആക്സസ് ചെയ്യാനും സഹായിക്കും.

ഇത് ചെയ്യുന്നതിന്, ഡാങ്കോയിലേക്ക് നിർമ്മിച്ച ഉപയോക്തൃ മോഡൽ ഞങ്ങൾ ഉപയോഗിക്കേണ്ടതുണ്ട്. ഞങ്ങളുടെ പോസ്റ്റ് പോലുള്ള ഡാറ്റാബേസ് മോഡലാണ് ഉപയോക്തൃ മോഡൽ, അത് ഒരു ഉപയോക്താവിനെ വെബ്സൈറ്റിൽ ലോഗിൻ ചെയ്യുന്നതിന് റെൻഡർ ചെയ്യാൻ കഴിയും. ഭാവിയിൽ, ഞങ്ങൾ ഇന്റർനെറ്റിൽ വിന്യസിക്കുന്നതിന് മുമ്പ്, മറ്റ് മോഡലുകളുമായി ഞങ്ങൾ ഈ മോഡലുകൾ ഉപയോഗിച്ച് വിപുലീകരിക്കും, ഒപ്പം ഫിഷിംഗിനെ പ്രതിരോധിക്കുന്ന ലോഗിൻ ചെയ്യുന്നതിനായി അധിക സുരക്ഷാ നടപടികൾ സ്ഥാപിക്കും. കാർങ്കോ നൽകുന്ന ലോഗിൻ ഫോമുകളിൽ നിർമ്മിച്ച ചിലത് ഉപയോഗിച്ചുകൊണ്ട് ഞങ്ങൾ ആരംഭിക്കും. ആദ്യം, അടിസ്ഥാന ലോഗിൻ പേജിനായി ടെംപ്ലേറ്റുകളും കാഴ്ചകളും റെൻഡർ ചെയ്യുന്നതിന് ഞങ്ങൾ ഉപയോഗിക്കുന്ന ഒരു പുതിയ അപ്ലിക്കേഷൻ സൃഷ്ടിക്കാം. ഫീൽഡ് കമ്മ്യൂണിക്കേഷൻ, ബാഹ്യ ഉപകരണങ്ങൾ, മൾട്ടി ഫാക്ടർ പ്രാമാണീകരണം, ഫിംഗർപ്രിന്റ് തിരിച്ചറിയൽ എന്നിവയുൾപ്പെടെയുള്ള അപ്ലിക്കേഷൻ സുരക്ഷിതമാക്കുന്നതിന് തുടർച്ചയായ ലോഗിൻ വെല്ലുവിളികളെ പ്രതിനിധീകരിക്കുന്നതിന് ഞങ്ങൾ മറ്റ് അപ്ലിക്കേഷനുകളും സൃഷ്ടിക്കും.

ഒരു അപ്ലിക്കേഷൻ ആരംഭിക്കുന്നതിനെക്കുറിച്ച് ഞങ്ങൾ ഇതിനകം സംസാരിച്ചു. ഞങ്ങളുടെ ഡയറക്ടറിയിൽ നിന്ന്, വെർച്വൽ പരിതസ്ഥിതിക്കുള്ളിൽ, കൈമാറാൻ. ഈ വാദങ്ങൾ

python manage.py startapp users

ഇപ്പോൾ, പുതിയ അപ്ലിക്കേഷനായി ഞങ്ങൾക്ക് ഒരു ഡയറക്ടറി ഉണ്ടായിരിക്കണം. ഉപയോക്തൃ ലോഗിൻ അനുസരിച്ച് ആ ഡയറക്ടറിയിൽ ഒരു കാഴ്ച സൃഷ്ടിക്കുന്നതിലൂടെ ആരംഭിക്കാം. ഉപയോക്തൃ ലോജിനുകൾക്കായുള്ള കാഴ്ചപ്പാടുകളാണ് ജാങ്കോ നിർമ്മിച്ചിരിക്കുന്നത്, എന്നാൽ ഇവ ഞങ്ങൾക്ക് അനുയോജ്യമാകില്ല, കാരണം ഞങ്ങൾക്ക് ഒരു ഇഷ്ടാനുസൃത കാഴ്ച ആവശ്യമാണ്, അത് ഒരു നിർവചനം ഉപയോഗിച്ച് ചെയ്യുന്നു.

ഈ കാഴ്ചയിൽ, ഒരു പോസ്റ്റ് അഭ്യർത്ഥനയ്ക്കായി പരിശോധിച്ച് ഞങ്ങൾ ആരംഭിക്കും. ഒരു ലോജിൻഫോമിലേക്ക് നിങ്ങൾ ആരംഭിക്കും

ഉപയോക്താക്കൾ / views.py, ഇനിപ്പറയുന്ന കോഡ് ചേർക്കുക

        username = request.POST['username'] # പോസ്റ്റ് അഭ്യർത്ഥന മുതൽ ഉപയോക്തൃനാമവും പാസ്വേഡും നേടുക
        password = request.POST['password'] # ഉപയോക്താവിനെ പ്രാമാണീകരിക്കുക

ഒരു അടിസ്ഥാന ലോഗിൻ കാഴ്ചയ്ക്കായി നിങ്ങൾക്കാവശ്യമാണ്. ഇപ്പോൾ, അടിസ്ഥാന ടെംപ്ലേറ്റ് വിപുലീകരിച്ച് കാഴ്ചയ്ക്കായി ഒരു ഫോം സൃഷ്ടിക്കാം. ഉപയോക്താക്കളുടെ ഫോൾഡറിലെ ടെംപ്ലേറ്റുകൾക്കായി ഒരു പുതിയ ഡയറക്ടറി സൃഷ്ടിച്ചുകൊണ്ട് ഞങ്ങൾ ആരംഭിക്കും.

mkdir users/templates
mkdir users/templates/users

ഇപ്പോൾ, ഉപയോക്താക്കളെ / ടെംപ്ലേറ്റുകൾ / ഉപയോക്താക്കൾ / login.html എഡിറ്റുചെയ്യാൻ നമുക്ക് കഴിയണം. ഞങ്ങൾ അതിലുണ്ടെങ്കിലും, സൈൻ അപ്പ് ചെയ്യാൻ ഉപയോക്താവിനെ അനുവദിക്കുന്നതിന് ഞങ്ങൾ ഒരു ടെംപ്ലേറ്റ് സൃഷ്ടിക്കും.

nano users/templates/users/login.html

ഇപ്പോൾ, ടെംപ്ലേറ്റിൽ,

ഇതാണ് ഒരു ലോഗിൻ ടെംപ്ലേറ്റിന്റെ അടിസ്ഥാനകാര്യങ്ങൾ. ഇത് ശരിക്കും ഘടനയിലെ മറ്റ് ടെംപ്ലേറ്റ് പോലെയാണ്, പക്ഷേ അത് റെൻഡർ ചെയ്യുമ്പോൾ അത് അൽപ്പം വ്യത്യസ്തമായി കാണപ്പെടുന്നു. രജിസ്റ്റർ.എച്ച്ടിഎംഎൽ എന്ന് വിളിക്കാൻ ഞങ്ങൾക്ക് ഈ കോഡ് പകർത്താൻ കഴിയും. നമുക്ക് ആദ്യം ടെംപ്ലേറ്റ് ഉണ്ടാക്കാം. ഉപയോക്താക്കൾ / ടെംപ്ലേറ്റുകൾ / ഉപയോക്താക്കൾ / രജിസ്റ്റർ ചെയ്യുക / രജിസ്റ്റർ ചെയ്യുക, ഇനിപ്പറയുന്ന കോഡ് ചേർക്കുക:

ഇപ്പോൾ, ഞങ്ങളുടെ ഉപയോക്തൃ രജിസ്ട്രേഷനായി ഞങ്ങളുടെ ഒരു ഫോം നിർമ്മിക്കാനും ഞങ്ങളുടെ ഉപയോക്തൃ ലോജിനുകൾ ഒരു മോഡലിനൊപ്പം നവീകരിക്കുന്നതിന് മുമ്പ് നമുക്ക് കാഴ്ചപ്പാടുകളിലേക്ക് തിരികെ വയ്ക്കാം. ഞങ്ങൾ ഈ ഫോം ബേസിക് ആസൂത്രണം ചെയ്യുന്നതിന് അടിസ്ഥാനപരമായി നിർമ്മിക്കും, പക്ഷേ ഭാവിയിൽ കൂടുതൽ വിശദാംശങ്ങളും സുരക്ഷാ സവിശേഷതകളും ഉൾക്കൊള്ളുന്നു. നാനോ ഉപയോക്താക്കളുപയോഗിച്ച് ഫോമുകൾ എഡിറ്റുചെയ്യുക / ഫോം. PY, ഇനിപ്പറയുന്ന കോഡ് ചേർക്കുക.

from django import forms
from django.contrib.auth.models import User
from django.contrib.auth.forms import UserCreationForm

class UserRegisterForm(UserCreationForm):
    email = forms.EmailField()

    class Meta:
        model = User
        fields = ['username', 'email', 'password1', 'password2']

അതിനാൽ ഞങ്ങൾക്ക് ഇവിടെ മറ്റൊരു രൂപമുണ്ട്, അത് ലളിതമായി പ്രവർത്തിക്കുന്നു. ഒരു ഉപയോക്തൃനാമം, ഇമെയിൽ, പാസ്വേഡ്, കൂടാതെ പാസ്വേഡ് ഫീൽഡ് എന്നിവ ഉപയോഗിച്ച് ഇത് ഒരു ഉപയോക്തൃ രജിസ്റ്റർ ഫോമുമാണ്. ഈ ഫോം പതിവ് ഫോം ഓഫ് ചെയ്യുന്നില്ലെന്നത് ശ്രദ്ധിക്കുക. ഇതിന് ഒരു മാതൃകാ രൂപമാണ്, അതിനർത്ഥം ഇതിന് ഒരു മെറ്റാ ഉണ്ട്. ഒരു ഫീൽഡ് അതേപടി നിർവചിച്ചിരിക്കുന്നു, ഫോമിലേക്ക് എഴുതപ്പെടുന്ന ബാക്കി വിവരങ്ങളുമായി പൊരുത്തപ്പെടുന്ന മാതൃകയാണ് ക്ലാസ് മെറ്റാ നിർവചിക്കുന്നു. അമേരിക്കൻക്രാങ്കോയിൽ നിർമ്മിച്ച ക്ജങ്കോയിൽ നിർമ്മിച്ചതിൽ ഇതിൽ ഭൂരിഭാഗവും ഇതിനകം നിലവിലുണ്ട്, അതിനാൽ ഞങ്ങൾ അത് ക്ലാസിന്റെ അടിസ്ഥാനമായി ഉപയോഗിക്കും (പരാൻതീസിസിൽ കടന്നുപോയി).

അടുത്തതായി, ഒരു ഉപയോക്താവിനെ രജിസ്റ്റർ ചെയ്യുന്നതിനുള്ള കാഴ്ച ഞങ്ങൾ പരിശോധിക്കും, ഇപ്പോൾ ഞങ്ങൾക്ക് ഒരു ഫോമും ടെംപ്ലേറ്റ് ഉണ്ടെന്നും. പുതിയ പോസ്റ്റ് കാഴ്ചയിലെ ഒന്ന് പോലെ ഇത് ഒരു മാതൃകാമമാണ്. ഉപയോക്താക്കളെ എഡിറ്റുചെയ്യുക / Views.py ചെയ്ത് ഇനിപ്പറയുന്ന കോഡ് ചേർക്കുക:

# ... ഇറക്കുമതി

രജിസ്റ്റർ ചെയ്ത ഒരു ഉപയോക്താവിനെ ലഭിക്കേണ്ടത് ഇതാണ്, പക്ഷേ ഞങ്ങൾക്ക് കൂടുതൽ വിവരങ്ങൾ ഉണ്ടായിരിക്കണം. ഉപയോക്താവിനെ രജിസ്റ്റർ ചെയ്ത സമയം, അവയെക്കുറിച്ചുള്ള ചില വിവരങ്ങൾ, അവയെക്കുറിച്ചുള്ള ചില വിവരങ്ങൾ, ഒരു ജീവചരിത്രം, സമയമേഖല മുതലായവ. അത് ചെയ്യുന്നതിന്, ഞങ്ങൾ രണ്ട് അപ്ലിക്കേഷനുകളിലും മോഡലുകൾ അപ്ഡേറ്റ് ചെയ്യും. ഫീഡ് മോഡൽ എഡിറ്റുചെയ്ത് ആരംഭിക്കാം. ഇത് ഇപ്പോൾ ഇങ്ങനെയായിരിക്കണം:

from django.db import models # ... ഇറക്കുമതി
    author = models.ForeignKey(User, on_delete=models.CASCADE, null=True, blank=True, related_name='posts') # ഈ വരിയിൽ ചേർക്കുക

ഫയലിലേക്ക് ചേർത്ത രണ്ടാമത്തെ വരിയിലേക്ക് ശ്രദ്ധിക്കുക. ഇതൊരു വിദേശ താക്കോലാണ്, ഇത് ഓരോ പോസ്റ്ററിന് ഒരൊറ്റ ഉപയോക്താവിലേക്ക് ആട്രിബ്യൂട്ട് ചെയ്യും, അതിനാൽ ഞങ്ങൾ ഒരു ഉപയോക്താവിന് ഒരു ഉപയോക്തൃ അടിസ്ഥാനത്തിൽ പോസ്റ്റുകൾ സംരക്ഷിക്കും, ഒരു ഉപയോക്താവിന് ആട്രിബ്യൂട്ട് ചെയ്യാതെ ഒരു പോസ്റ്റിനും നിർമ്മിക്കാൻ കഴിയില്ല. ആവശ്യമെങ്കിൽ ഉപയോക്താക്കൾ, അസാധുവായ, ശൂന്യമായ വാദങ്ങൾ എന്നിവ ഉപയോഗിച്ച് ഞങ്ങൾ ഈ വിദേശ കീയെ നിർവചിക്കുന്നു, മാത്രമല്ല ഞങ്ങൾ ഇതിനകം സൃഷ്ടിക്കപ്പെട്ട പോസ്റ്റുകളിലെ ഒരു ഉപയോക്താവിനും അനുബന്ധ നാമം, ഉപയോക്താവ് സൃഷ്ടിക്കുന്ന ഒരു അനുബന്ധ നാമം എന്നിവ ഉൾക്കൊള്ളുന്നു. ഈ അനുബന്ധ പേര്, പോസ്റ്റിന്റെ രചയിതാവായ പോസ്റ്റ്. User.ossuts.ossuts.ossuts.ossuts.oss.ossuts.oss.oss.oss.oss.oss.oss.oss.oss.oss.oss.oss.oss.ult () പ്രവർത്തിപ്പിച്ചുകൊണ്ട് ഞങ്ങൾക്ക് ഇപ്പോൾ ലഭിക്കാൻ കഴിയും.

ഇപ്പോൾ, ഞങ്ങളുടെ ലോഗിനുകളെ കൂടുതൽ വേഗത്തിലാക്കാം. സൈറ്റിലേക്ക് ഒരു ലോഗിൻ അനുവദിക്കുന്ന സമയങ്ങൾ പരിമിതപ്പെടുത്തുന്നതിലൂടെ ഞങ്ങൾക്ക് ഇതിനകം ഞങ്ങളുടെ സൈറ്റിനെ ഫിഷിംഗിന് ഇരയാകാൻ സാധ്യതയുണ്ട്, ഇത് വളരെ എളുപ്പമാണ്. ഞങ്ങളുടെ അപ്ലിക്കേഷൻ വികസിപ്പിക്കുന്നത് തുടരുമ്പോൾ ഓരോ ഉപയോക്താവിനെയും കുറിച്ചുള്ള ചില വിവരങ്ങൾ സൂക്ഷിക്കാൻ കഴിയില്ല. ഉപയോക്താക്കൾ / മോഡലുകൾ .പി എഡിറ്റിംഗ്, ഇനിപ്പറയുന്ന കോഡ് ചേർക്കുക.

from django.db import models
from django.contrib.auth.models import User
from django.utils import timezone

class Profile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE, null=True, blank=True, related_name='profile')
    account_created = models.DateTimeField(default=timezone.now)
    last_seen = models.DateTimeField(default=timezone.now)
    can_login = models.DateTimeField(default=timezone.now)
    preferred_name = models.CharField(max_length=20,default='', null=True, blank=True)
    bio = models.TextField(blank=True, default='')

ഈ മോഡൽ പോസ്റ്റ് മോഡലിന് സമാനമാണ്. ഞങ്ങൾക്ക് ഒരു അധിക ഇറക്കുമതി ഉണ്ട്, സമയമേഖല, ഡേറ്റൈം ഫീൽഡുകളിൽ സ്ഥിരസ്ഥിതികൾ സജ്ജമാക്കാൻ ഞങ്ങളെ അനുവദിക്കുന്നതും പോസ്റ്റിനെപ്പോലെ ഒരു പ്രതീകം, ടെക്സ്റ്റ്ഫീൽഡും ഉണ്ട്. ഈ ടൈംസ്റ്റാമ്പുകളും ഉപയോഗിച്ച് സൈറ്റ് സുരക്ഷിതമാക്കുകയും അതിന്റെ ഉപയോഗം മനസിലാക്കുകയും ടെക്സ്റ്റ് ഫീൽഡുകൾ ഓരോ ഉപയോക്താവിനെയും അല്ലെങ്കിൽ രചയിതാവിനെയും കുറിച്ചുള്ള വിവരങ്ങൾ നമുക്ക് അനുവദിക്കുന്നു. ഒട്റ്റൂണിഫീൽഡ് ഏകസംഘടനയായിരിക്കണം, ഇത് ഒരു മുൻകാല മോഡലിന് തുല്യമായി പെരുമാറുന്നു, പക്ഷേ അത് തുടർന്നുള്ള മാതൃകയിൽ മാത്രം. ഈ രീതിയിൽ, ഉപയോക്താവിന് ഒരു പ്രൊഫൈൽ മാത്രമേയുള്ളൂ, അവർക്ക് ധാരാളം പോസ്റ്റുകൾ ഉണ്ടായിരിക്കാം.

ഇപ്പോൾ, ഞങ്ങളുടെ ലോഗിൻ മെച്ചപ്പെടുത്തുകയും പ്രൊഫൈലിനായി അക്കൗണ്ടിലേക്ക് കാഴ്ചകൾ രജിസ്റ്റർ ചെയ്യാം. ആദ്യം, ഉപയോക്താക്കൾ / കാഴ്ചകൾ. PPY എഡിറ്റുചെയ്യുക, രജിസ്റ്റർ കാഴ്ചയിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുക:

# ... ഇറക്കുമതി
            Profile.objects.create(user=user) # ഉപയോക്താവിനായി ഒരു പ്രൊഫൈൽ സൃഷ്ടിക്കുന്നതിന് ഈ വരി ചേർക്കുന്നത് ഉറപ്പാക്കുക

ഇത് ഏതെങ്കിലും വിവരങ്ങൾ പൂരിപ്പിക്കാതെ ഉപയോക്താവിനായി ഒരു പ്രൊഫൈൽ സൃഷ്ടിക്കുന്നു. ഇപ്പോൾ, ഉപയോക്തൃ അക്കൗണ്ട് പലപ്പോഴും ലോഗിൻ ചെയ്യാൻ കഴിയില്ലെന്ന് ഉറപ്പാക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു, അല്ലെങ്കിൽ കുറഞ്ഞത് പാസ്വേഡുകൾ പലപ്പോഴും ശ്രമിക്കാൻ കഴിയില്ല, അതിനാൽ ലോഗിൻ കാഴ്ച നമുക്ക് അപ്ഡേറ്റ് ചെയ്യാം.

# ... ഇറക്കുമതി
        if user and user.profile.can_login < timezone.now(): # ഉപയോക്താവിന് ലോഗിൻ ചെയ്യാൻ കഴിയുമോ എന്ന് ശ്രദ്ധിക്കുക
        else: # ലോഗിൻ വിജയിച്ചില്ലെങ്കിൽ,
            user = User.objects.filter(username=username).first() # ഉപയോക്താക്കൾ പ്രൊഫൈൽ അപ്ഡേറ്റ് ചെയ്യുന്ന ഭാഗം ഇതാണ്
                profile.can_login = timezone.now() + datetime.timedelta(seconds=15) # അതിനാൽ അവർക്ക് കുറച്ച് നിമിഷങ്ങൾ വീണ്ടും ലോഗിൻ ചെയ്യാൻ കഴിയില്ല

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

ഞങ്ങളുടെ ജോലി സംരക്ഷിക്കാൻ ഞങ്ങൾ ഒരു ബാക്കപ്പ് സ്ക്രിപ്റ്റ് നിർമ്മിച്ചതായി ഓർക്കുക, അതിനാൽ നമുക്ക് മുന്നോട്ട് പോകാനും ഞങ്ങൾ എല്ലാം സംരക്ഷിച്ചുവെന്ന് ഉറപ്പാക്കാനും അനുവദിക്കുക. കമാൻഡ് പ്രവർത്തിപ്പിക്കുക:

sudo backup

ഇത് വീണ്ടും, ഇത് നിങ്ങളുടെ ജോലി ഇതുവരെ സംരക്ഷിക്കും. നിങ്ങളുടെ ജോലി സംരക്ഷിക്കുന്നതിന് പതിവ് ബാക്കപ്പുകൾ പ്രവർത്തിപ്പിക്കാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു, കൂടാതെ ഒരു ബാക്കപ്പ് ജോലി സ്വപ്രേരിതമായി പ്രവർത്തിപ്പിക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം. ക്രോൺ എന്ന യുണിക്സ് യൂട്ടിലിറ്റി ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇത് ചെയ്യാൻ കഴിയും. ഈ യൂട്ടിലിറ്റി സജീവമാക്കുന്നതിന്, ഇനിപ്പറയുന്ന കമാൻഡ് പ്രവർത്തിപ്പിച്ച് പാസ്വേഡ് നൽകുക:

sudo crontab -e

നിങ്ങൾ ഇതിനകം തന്നെ ഓപ്ഷൻ 1 ഇൻസ്റ്റാൾ ചെയ്തിട്ടില്ലെങ്കിൽ, നിങ്ങൾ ഇതിനകം പരിചിതമായിരിക്കണമെന്ന ടെക്സ്റ്റ് എഡിറ്റർ അമ്പടയാള കീകൾ ഉപയോഗിച്ച് ഫയലിന്റെ അടിയിലേക്ക് സ്ക്രോൾ ചെയ്യുകയും വേണം. ഇനിപ്പറയുന്ന വരി ചേർക്കുക:

0 * * * * sudo backup

ക്രോൺ ഫോർമാറ്റ് മിനിറ്റ്, മണിക്കൂർ, മാസം, മാസം, ആഴ്ച, ആഴ്ച, ആഴ്ച, ആഴ്ച, ഒരു സംഖ്യ എന്നിവ ഉപയോഗിക്കുന്നു, അവിടെ ഒരു നമ്പർ ആജ്ഞാപിക്കും. മിനിറ്റിന് 0 ഉം * ബാക്കി ഓപ്ഷനുകളുടെയും ബാക്കി ഓപ്ഷനുകൾക്കായി, നിമിഷത്തിന്റെ തുടക്കത്തിൽ ഓരോ മണിക്കൂറിലും ആദ്യ നിമിഷത്തിൽ ഒരു കമാൻഡ് പ്രവർത്തിപ്പിക്കാൻ കഴിയും. ഇത് കോഡ് യാന്ത്രികമായി ബാക്കപ്പ് ചെയ്യാൻ ഞങ്ങളെ അനുവദിക്കുന്നു. സുഡോ ഉപയോഗിച്ച് വധിക്കുമ്പോൾ എല്ലാ ക്രോണിന്റെ ജോലിയും റൂട്ടായി പ്രവർത്തിക്കുമ്പോൾ, അതിനാൽ ഓരോ മണിക്കൂറിലും പാസ്വേഡ് ടൈപ്പുചെയ്യേണ്ടതില്ല.

പാസ്വേഡ് ഉപയോഗിക്കാതെ ഞങ്ങളുടെ കോഡ് ബാക്കപ്പ് ചെയ്യുന്നത് എളുപ്പമാക്കുന്നതിന്, ഞങ്ങളുടെ ബാക്കപ്പ് കമാൻഡിനായി പാസ്വേഡ് അപ്രാപ്തമാക്കാം. ഇനിപ്പറയുന്ന കമാൻഡ് നടപ്പിലാക്കുന്നതിലൂടെ ഞങ്ങൾ ഇത് ചെയ്യും, പാസ്വേഡ് നൽകുക:

sudo visudo

ഇപ്പോൾ, നമുക്ക് ഫയലിന്റെ അടിയിലേക്ക് സ്ക്രോൾ ചെയ്ത് മറ്റൊരു വരി ചേർക്കാം:

ALL ALL=NOPASSWD: /bin/backup

പാസ്വേഡ് ഇല്ലാതെ ഏത് ഉപയോക്താവായി "ബാക്കപ്പ്" കമാൻഡ് പ്രവർത്തിപ്പിക്കാൻ ഇത് ഞങ്ങളെ അനുവദിക്കുന്നു. ഇതിനായുള്ള ഫോർമാറ്റ് എളുപ്പമാണ്, "എല്ലാം = നോപാസ്വ്ഡ്: / ബിൻ /" ഉപയോഗിച്ച് ലൈൻ പ്രിഫിക്സ് ചെയ്യുക, ഉദാഹരണത്തിന് / bin / ബാക്കപ്പ്, ഇത് / usr / bin / ൽ നിലവിലുണ്ട്, അത്.

ഇപ്പോൾ നമുക്ക് ഇമെയിൽ ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ ആരംഭിക്കാം. ഇമെയിൽ വെബ്സൈറ്റുകൾക്ക് ഇമെയിൽ ശരിക്കും പ്രധാനമാണ്, കാരണം ഒരു വെബ്സൈറ്റ് കൂടുതൽ സുരക്ഷിതമായി സൂക്ഷിക്കാനുള്ള മാർഗമാണിത്, ഉപയോക്താക്കളെ സ്ഥിരീകരിക്കുക യഥാർത്ഥ ആളുകളുമായാണ്, കമ്പോള ഉൽപ്പന്നങ്ങൾ അല്ലെങ്കിൽ ഉപഭോക്താക്കൾക്ക് പോലും. ഇന്റർനെറ്റ് പതിവായി ഇൻറർനെറ്റ് പതിവ് വരുത്തുന്ന പലരും ദിവസവും അവരുടെ ഇമെയിൽ പരിശോധിക്കുന്നു, അവർക്ക് താൽപ്പര്യമുള്ള ഉൽപ്പന്നങ്ങളെയും സേവനങ്ങളെയും കുറിച്ചുള്ള എല്ലാത്തരം മാർക്കറ്റിംഗ് ഇമെയിലും ലഭിക്കും. ഒരു ജാങ്കോ വെബ്സൈറ്റിൽ ഇമെയിൽ പ്രാപ്തമാക്കുമ്പോൾ, നിങ്ങൾക്ക് ഏറ്റവും മികച്ച രീതിയിൽ പ്രവർത്തിക്കാൻ സ്വാഗതം.

ആദ്യം, നിങ്ങളുടെ ഡൊമെയ്നിൽ നിന്ന് ഇമെയിൽ അയയ്ക്കാനും കുറഞ്ഞ കോഡ് ആവശ്യമുള്ള ഒരു ഇമെയിൽ സേവനത്തിനായി നിങ്ങൾക്ക് പണമടയ്ക്കാം. Google വർക്ക്സ്പെയ്സ്, അയച്ചയാൾ, മെയിൽഗൺ എന്നിവയും അതിലേറെയും പോലുള്ള നിരവധി സേവനങ്ങളുണ്ട്.

അല്ലെങ്കിൽ, ആദ്യം മുതൽ നിങ്ങളുടെ സെർവറിനുള്ളിൽ നിങ്ങളുടെ സ്വന്തം ഇമെയിൽ സേവനം നിർമ്മിക്കുക. കൂടുതൽ കോഡ് കൂടുതലാണെങ്കിലും പ്രത്യേക ഹോസ്റ്റിംഗ് ആവശ്യമാണെങ്കിലും ഞാൻ ഈ ഓപ്ഷൻ ശുപാർശ ചെയ്യുന്നു. നിങ്ങളുടെ ഹോം കമ്പ്യൂട്ടറിൽ നിന്ന് ഒരു മെയിൽ സെർവർ ആരംഭിക്കാൻ നിങ്ങൾക്ക് കഴിയില്ല, അതിനാൽ നമുക്ക് മുന്നോട്ട് പോയി കോൺഫിഗറേഷനും ഓർഡറും പരിശോധിച്ച് ഇമെയിൽ അയയ്ക്കുന്നതിന് മുമ്പ് ഞങ്ങളുടെ സ്വന്തം മെയിൽ സെർവർ സൃഷ്ടിക്കുന്നതിന് മുമ്പ് പരിശോധിക്കാം.

ആദ്യം, ക്രമീകരണങ്ങൾ എഡിറ്റുചെയ്യുക ഇനിപ്പറയുന്ന കമാൻഡ് ഉപയോഗിച്ച്:

nano app/settings.py

നിങ്ങൾ സ്റ്റാർട്ടപ്പ് ഉപയോഗിച്ച് സൃഷ്ടിച്ച അപ്ലിക്കേഷന്റെ പേരാണ് അപ്ലിക്കേഷൻ.

ഇനിപ്പറയുന്ന വരികൾ ചേർക്കുക:

SITE_NAME = 'Django App'

EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = 'localhost'
EMAIL_PORT = 587
EMAIL_USE_TLS = True
EMAIL_ADDRESS = username@server.com'
EMAIL_HOST_USER = 'username'
EMAIL_HOST_PASSWORD = config['EMAIL_HOST_PASSWORD']
DEFAULT_FROM_EMAIL = '{} <{}>'.format(SITE_NAME, EMAIL_HOST_USER)

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

import os
import json
with open('/etc/config.json') as config_file:
    config = json.load(config_file)

പിന്നെ, നാനോ ഉപയോഗിച്ച് നിങ്ങൾ /etc/config.json- ലെ കോൺഫിഗറക് ഉപയോഗിച്ച് ഒരു JSON ഫയൽ സജ്ജമാക്കി.

ഫയൽ എഡിറ്റുചെയ്യുന്നതിന്:

sudo nano /etc/config.json

ഇനിപ്പറയുന്ന വരികൾ ചേർക്കുക:

{
	"EMAIL_HOST_PASSWORD": "<some password here>"
}

ഞങ്ങൾ അപ്ലിക്കേഷനിൽ ഉപയോഗിക്കുന്ന എല്ലാ പാസ്വേഡുകളും കീകളും എഡിറ്റുചെയ്യാനും എല്ലാ പാസ്വേഡുകളും കീകളും ചേർക്കുന്നത് ഞങ്ങൾ തുടരും. ഇപ്പോൾ, പൈത്തൺ ഉപയോഗിച്ച് ഇമെയിൽ എങ്ങനെ അയയ്ക്കാമെന്ന് ഇപ്പോൾ നമുക്ക് വേഗത്തിൽ പരിശോധിക്കാം. ആദ്യം, ഒരു സ്ഥിരീകരണ ഇമെയിലിനായി ഒരു ടെംപ്ലേറ്റ് സൃഷ്ടിക്കാം ഞങ്ങളുടെ ഉപയോക്താക്കൾക്ക് അയയ്ക്കാൻ ഞങ്ങൾക്ക് ഉപയോക്തൃ ടെംപ്ലേറ്റ്സ് ഡയറക്ടറിയിൽ ഇടുക. ഈ ടെംപ്ലേറ്റ് HTML- ൽ എഴുതാം.

nano users/templates/users/verification_email.html

ഈ ഇമെയിൽ വളരെ ലളിതമാണ്. ഒരു ഉപയോക്താവിന്റെ ഒരു സന്ദർഭം, സൈറ്റിനായുള്ള അടിസ്ഥാന URL, ഉപയോക്താവിന്റെ ഇമെയിൽ സ്ഥിരീകരിക്കുന്നതിന് ഉപയോഗിക്കുന്ന ഒരു ഉപയോക്തൃ ഐഡി, ടോക്കൺ എന്നിവയും ആവശ്യമാണ്. ടെംപ്ലേറ്റ് റെൻഡർ ചെയ്യുന്നതിന് ചില പൈത്തൺ കോഡ് എഴുതുന്നതിനുമുമ്പ് ക്രമീകരണത്തിലേക്കുള്ള അടിസ്ഥാന URL നിർവചിക്കുന്നത് ഉറപ്പാക്കുക. മുന്നോട്ട് പോയി App / spertings ression.py- ലേക്ക് ഇനിപ്പറയുന്ന ലൈനുകൾ ചേർക്കുക.

SITE_NAME = 'Django App'
PROTOCOL = 'https'
DOMAIN = 'example.com'

BASE_URL = PROTOCOL + '://' + DOMAIN

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

ഞങ്ങൾ ഇമെയിൽ അയയ്ക്കുന്നതിന് മുമ്പ്, നമുക്ക് ഒരു ടോക്കൺ ജനറേറ്റർ സൃഷ്ടിക്കാം, അതിനാൽ ഞങ്ങൾക്ക് ഒരിക്കലും കാലഹരണപ്പെടാത്ത ഒരു അക്കൗണ്ട് സജീവമാക്കൽ ടോക്കൺ ഉണ്ടായിരിക്കാം. ഇനിപ്പറയുന്നവ പോലെ കാണപ്പെടുന്ന ഒരു അക്കൗണ്ട് സജീവമാക്കൽ ടോക്കൺ നിർമ്മിച്ച് ഇറക്കുമതി ചെയ്യുന്നതിലൂടെ ഞങ്ങൾക്ക് ഇത് ചെയ്യാൻ കഴിയും. ഫയൽ എഡിറ്റുചെയ്യുക:

nano users/tokens.py

ഇനിപ്പറയുന്ന കോഡ് ചേർക്കുക:

from django.contrib.auth.tokens import PasswordResetTokenGenerator
import six
class TokenGenerator(PasswordResetTokenGenerator):
    def _make_hash_value(self, user, timestamp):
        return (
            six.text_type(user.pk) + six.text_type(timestamp)
        )
account_activation_token = TokenGenerator()
unsubscribe_token = TokenGenerator()

ഈ അടിസ്ഥാന ടോക്കൺ ജനറേറ്റർ ഒരു ടോക്കൺ സൃഷ്ടിക്കുന്നു, ഞങ്ങൾക്ക് ഉപയോക്താവിന് ഒരു URL- ൽ ഉപയോക്താവിന് അയയ്ക്കാനും അവരുടെ ഇമെയിൽ സ്ഥിരീകരിക്കാനും അവയുടെ അക്കൗണ്ട് സജീവമാക്കാനും കഴിയും.

അടുത്തതായി, ഒരു ഇമെയിൽ എങ്ങനെ അയയ്ക്കാമെന്ന് നോക്കാം. നാനോ ഉപയോഗിച്ച് ഉപയോക്താക്കൾ / ഇമെയിൽ എഡിറ്റുചെയ്യുക.

nano users/email.py

സ്ഥിരീകരണം അയയ്ക്കുന്നത് HTML ഇമെയിൽ അയയ്ക്കുന്നത് ഇതുപോലെ കാണപ്പെടും:

from django.contrib.auth import get_user_model
from django.utils.http import urlsafe_base64_encode, urlsafe_base64_decode
from django.contrib.sites.shortcuts import get_current_site
from django.core.mail import send_mail
from django.template.loader import render_to_string
from django.utils.encoding import force_bytes
from django.core.mail import EmailMultiAlternatives
from django.shortcuts import render
from .tokens import account_activation_token
from django.template.loader import render_to_string
from django.utils.html import strip_tags
from django.template import Template, Context
from django.conf import settings
import traceback

def send_verification_email(user):
    User = get_user_model()
    mail_subject = '[{}] Activate your account.'.format(settings.SITE_NAME)
    html_message = render_to_string('users/verification_email.html', {
        'user': user,
        'domain': settings.DOMAIN,
        'protocol': 'https',
        'uid': urlsafe_base64_encode(force_bytes(user.pk)),
        'token': account_activation_token.make_token(user),
    })
    send_html_email(user, mail_subject, html_message)

ഇത് വളരെ ലളിതമാണ്. ഞങ്ങൾ ഇമെയിൽ അയയ്ക്കേണ്ട പ്രവർത്തനങ്ങൾ ഞങ്ങൾ ഇമ്പോർട്ടുചെയ്യുന്നു, ടെംപ്ലേറ്റുകളാൽ ഇമെയിൽ റെൻഡർ ചെയ്യുക, ഞങ്ങളുടെ ക്രമീകരണങ്ങൾ ഉപയോഗിച്ച് ഞങ്ങൾ ഇമെയിൽ നിർവചിക്കുകയും ഒരു ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഉപയോക്താവിന് അയയ്ക്കുകയും ചെയ്യുന്നു. മെയിൽ അയയ്ക്കുന്നതിനായി ഞങ്ങൾ ഫംഗ്ഷൻ നിർവചിച്ചിട്ടില്ല, അയയ്ക്കുക_html_mamail അയയ്ക്കുക, എന്നിട്ടും ഉപയോക്താക്കൾ / ഇമെയിൽ. Py

def send_html_email(user, mail_subject, html_message):
    to_email = user.email
    username = user.username
    if to_email == '':
        return None
    unsub_link = settings.BASE_URL + user.profile.create_unsubscribe_link()
    html_message = html_message + "<p><a href=\"" + unsub_link +  "\" + title=\"Unsubscribe from " + settings.SITE_NAME + " emails\">Unsubscribe</a></p></body></html>"
    msg = EmailMultiAlternatives(mail_subject, strip_tags(html_message), settings.DEFAULT_FROM_EMAIL, [to_email], headers={'List-Unsubscribe' : '<' + unsub_link + '>'},)
    msg.attach_alternative(html_message, "text/html")
    profile = user.profile
    try:
        msg.send(fail_silently=False)
        if not profile.email_valid:
            profile.email_valid=True
            profile.save()
    except:
        profile.email_valid=False
        profile.save()

ഇത് അൽപ്പം സങ്കീർണ്ണമാണ്, മാത്രമല്ല ഈ കോഡുകളെല്ലാം ഇതുവരെ പ്രവർത്തിക്കാൻ ഞങ്ങൾ തയ്യാറല്ല. ഞങ്ങൾ ഒരു അൺസബ്_ലിങ്ക് നിർവചിക്കുന്നതാണെന്ന് ശ്രദ്ധിക്കുക, ഉപയോക്താവിന് ഞങ്ങളുടെ ഇമെയിലുകളിൽ നിന്ന് അൺസബ്സ്ക്രൈബുചെയ്യാൻ കഴിയുന്ന ലിങ്ക് ഉപയോഗിക്കാൻ കഴിയുന്ന ലിങ്ക്. ഇത് പ്രധാനമാണ്, കാരണം ഉപയോക്താക്കൾക്ക് എപ്പോൾ വേണമെങ്കിലും അവരെ കാണാൻ ആഗ്രഹിക്കുന്നില്ലെങ്കിൽ ഞങ്ങളുടെ ഇമെയിലുകൾ ഒഴിവാക്കാൻ കഴിയേണ്ടതുണ്ട്. ഞങ്ങളുടെ സന്ദേശത്തിനുള്ള ഒരു വാചകവും ഞങ്ങൾ ചേർക്കുന്നു, അത് HTML ടാഗുകൾ നീക്കംചെയ്തു. അവസാനമായി, ഇമെയിൽ അയച്ചിട്ടുണ്ടോയെന്ന് ഞങ്ങൾ പരിശോധിക്കുന്നു, അത് ചെയ്തില്ലെങ്കിൽ, അവരുടെ ഇമെയിൽ സാധുവല്ലെന്ന് ഉപയോക്താവിന്റെ പ്രൊഫൈലിൽ ഞങ്ങൾ അടയാളപ്പെടുത്തുന്നു.

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

ആദ്യം, ഉപയോക്താക്കളുടെ മുകളിലേക്ക് ഇനിപ്പറയുന്ന ഇറക്കുമതി ചേർക്കുക / മോഡലുകൾ.

nano users/models.py

# ...

അടുത്തതായി, ടോക്കൺ നിർമ്മിക്കുന്നതിന് ഉപയോക്തൃ മോഡലിലേക്ക് പ്രവർത്തിപ്പിച്ച് ഇമെയിൽ സജീവമാക്കുന്നതിന് ഉപയോഗിക്കുന്ന ടോക്കൺ, കൂടാതെ ഉപയോക്താവ് അവരുടെ മെയിൽ വിജയകരമായി ഉണ്ടോയെന്ന് സംരക്ഷിക്കുന്നതിനും ഫീൽഡ്. ഉപയോക്താക്കളിൽ / മോഡലുകൾ.പി വീണ്ടും, മോഡലിന്റെ അവസാനത്തിൽ ഇനിപ്പറയുന്ന കോഡ് ചേർക്കുക (ഇൻഡന്റ് കോഡ്)

# ...
            TimestampSigner().unsign(key, max_age=60 * 60 * 24 * 30) # 30 ദിവസത്തേക്ക് സാധുതയുണ്ട്

ഇത് വളരെ ലളിതമാണ്, ഇത് ഒരു പ്രത്യേക സമയത്തിന് ശേഷം കാലഹരണപ്പെടുന്ന ഒരു ടോക്കൺ സൃഷ്ടിക്കുന്നതിന് ഞങ്ങൾ ഒരു അടിസ്ഥാന ക്രിപ്റ്റോഗ്രഗ്രഗ്രഗ്രഗ്രബിഗ് ഉപകരണമാണ്, അത് സാധുതയുള്ളതാണോ എന്ന് പരിശോധിക്കേണ്ട മറ്റൊരു ഫംഗ്ഷൻ ഞങ്ങൾ ഉപയോഗിക്കുന്നു. ഇമെയിൽ സ്ഥിരീകരിക്കുന്നതിന് ഞങ്ങൾ ഈ ടോക്കണുകൾ രണ്ടുതവണ ഉപയോഗിക്കുന്നു, കൂടാതെ ഒരു അൺസബ്സ്ക്രൈബുചെയ്യാൻ ഒരിക്കൽ.

ഇപ്പോൾ നമുക്ക് ഇവ ഉള്ളതിനാൽ, ഞങ്ങൾ ചെയ്യേണ്ട ജോലി കാഴ്ചപ്പാടുകളിൽ മാത്രമാണ്. ഉപയോക്താക്കൾക്ക് / views.py, ഇമെയിൽ വിലാസം സ്ഥിരീകരിക്കുന്നതിനും അൺസബ്സ്ക്രൈബുചെയ്യുന്നതിന് കാഴ്ചകൾ ചേർക്കാം.

nano users/views.py

ആദ്യം, ഇനിപ്പറയുന്ന ഇറക്കുമതി ചേർക്കുക. കുറച്ച് അധികത്തിനുള്ളിൽ ഞാൻ എറിഞ്ഞു, അതിനാൽ ഞങ്ങൾ പിന്നീട് കൂടുതൽ ഇനങ്ങൾ ഇറക്കുമതി ചെയ്യേണ്ടതില്ല.

from .email import send_verification_email # ഫംഗ്ഷൻ അയയ്ക്കുന്ന സ്ഥിരീകരണ ഇമെയിൽ ഇറക്കുമതി ചെയ്യുന്നത് ഉറപ്പാക്കുക

ഈ ഇറക്കുമതി ഇതിനകം തന്നെ നിങ്ങൾക്ക് ഇതിനകം ഉണ്ടായിരിക്കാം, പക്ഷേ അവ ആവർത്തിക്കുന്നത് വേദനിപ്പിക്കുന്നില്ല. നിങ്ങൾ സ്ഥിരീകരണ ഇമെയിൽ അയയ്ക്കേണ്ടതുണ്ട്

ഇപ്പോൾ, ഫയലിന്റെ അടിയിൽ, ഇനിപ്പറയുന്ന കോഡ് ചേർക്കുക:

        # അവ ബഡ്ബിൽ ചെയ്യുക
    # അല്ലെങ്കിൽ ലോഗിൻ പേജ് റീഡയറക്ട് ചെയ്യുക
# അയച്ച വിഭജനം (അഭ്യർത്ഥന, ഉപയോക്താവ്)

ഇത് ധാരാളം കോഡാണ്. നമുക്ക് അത് തകർക്കാം. ആദ്യ പ്രവർത്തനം, വൃത്തിയുള്ളതും ലളിതവും, മെയിലിംഗ് ലിസ്റ്റിൽ നിന്ന് ഉപയോക്താവിനെ അൺസബ്സ്ക്രൈബുചെയ്യുന്നു. രണ്ടാമത്തെ ഫംഗ്ഷൻ അവരുടെ ഇമെയിൽ സജീവമാക്കുന്നു, മാത്രമല്ല ഞാൻ അഭിപ്രായമിട്ട പ്രവർത്തനം ചേർത്തത്, അയച്ച ഒരു ഫംഗ്ഷൻ ചേർത്തു. സ്വാഗത ഇമെയിൽ അയയ്ക്കുന്നതിന് ഒരു ഇമെയിൽ ടെംപ്ലേറ്റ്, ഫംഗ്ഷൻ നിർവചനം എന്നിവ ഉപയോഗിക്കാൻ നിങ്ങൾക്ക് സ്വാഗതം, ഞാൻ ഇതുവരെ ഇല്ല. ഞാൻ ഇരിക്കുന്ന അവസാന പ്രവർത്തനം പ്രധാനമാണ്, കാരണം സജീവമാക്കൽ ഇമെയിലുകൾ കാലഹരണപ്പെടും. അതിനാൽ, ഞങ്ങൾ ആക്റ്റിവേഷൻ ഇമെയിൽ ചില സമയങ്ങളിൽ വീണ്ടും അയയ്ക്കേണ്ടതുണ്ട്. ഇതിനായി ഞങ്ങൾക്ക് ഒരു അടിസ്ഥാന ഫോം ഉപയോഗിക്കാം, മാത്രമല്ല സ്ഥിരീകരണ ഇമെയിൽ അയയ്ക്കാൻ ഫംഗ്ഷൻ വിളിക്കാം. ഞങ്ങൾ ഇത് ചെയ്യുന്നതിന് മുമ്പ്, രജിസ്റ്റർ കാഴ്ചയ്ക്ക് ഒരു ഫംഗ്ഷൻ കോൾ ചേർക്കുന്നതിലൂടെ ഇത് ആദ്യം അയയ്ക്കുന്നുവെന്ന് ഉറപ്പാക്കാം. രജിസ്റ്റർ കാഴ്ചയിലെ റീഡയറക്ടുചെയ്യുന്നതിന് തൊട്ടുമുമ്പ്, ഡിഫൈഡ്, ഉപയോക്താക്കൾ / views.py എന്നിവയിൽ റീഡയറക്ട് ചെയ്യുന്നതിന് തൊട്ടുമുമ്പ് ഈ വരി ചേർക്കുക.

nano users/views.py

# ... (ശേഷം) ഡെഫ് രജിസ്റ്റർ (അഭ്യർത്ഥന):
# ... (മുമ്പ്) റീഡയറക്ട് (

ആ കോഡ് സ്നിപ്പെറ്റിലെ ആദ്യ, അവസാന വരികൾ നിങ്ങൾ ചേർക്കേണ്ടതില്ല, രജിസ്റ്റർ കാഴ്ച ഉപയോക്താവിന് സ്ഥിരീകരണ ഇമെയിൽ അയയ്ക്കുന്നുവെന്ന് ഉറപ്പാക്കുക. ഇത് ഇങ്ങനെയായിരിക്കണം:

# ... ഇറക്കുമതി
            send_verification_email(user) # ഈ ലൈൻ ചേർക്കുന്നത് ഉറപ്പാക്കുക!

ഇപ്പോൾ, ആക്റ്റിവേഷൻ ഇമെയിൽ വീണ്ടും അയയ്ക്കുന്നതിന് ഞങ്ങൾ ഒരു ഫോം ചേർക്കേണ്ടതുണ്ട്. ഉപയോക്താക്കളിൽ / ഫോം. PI, ഇനിപ്പറയുന്ന ഫോം ചേർക്കുക:

# ... (ഇറക്കുമതി)

ഈ പുന in സ്ഥാപിക്കൽ ഇമെയിൽ സജീവമാക്കൽ ഫോമിന് സമാനമായ ഒരു ടെംപ്ലേറ്റ് ഞങ്ങൾക്ക് ആവശ്യമാണ്. ഈ ടെംപ്ലേറ്റ് ചേർക്കാം. ഫയൽ എഡിറ്റുചെയ്യുക:

nano users/templates/users/resend_activation.html

അടുത്തതായി, ഫയലിലേക്ക് ഇനിപ്പറയുന്ന കോഡ് ചേർക്കുക.

ഭ്വീ, അത് ഒരുപാട്! ഇപ്പോൾ, ഞങ്ങൾ ഞങ്ങളുടെ സെർവറിലേക്ക് കോഡ് വിന്യസിക്കുമ്പോൾ, ഞങ്ങൾക്ക് HTML ഇമെയിൽ അയയ്ക്കാനും ഇമെയിലിൽ ഒരു ക്ലിക്കിലൂടെ ഉപയോക്തൃ അക്കൗണ്ടുകൾ സജീവമാക്കാനും കഴിയും. ലളിതമായ സ്വാഗത ഇമെയിൽ അയയ്ക്കാനും ഞങ്ങൾ ആഗ്രഹിച്ചേക്കാം, അതിനാൽ അത് എങ്ങനെ ചെയ്യാമെന്ന് നോക്കാം. ഉപയോക്താക്കളിൽ മടങ്ങുക / ഇമെയിൽ. PY, ഇനിപ്പറയുന്ന കോഡ് ചേർക്കുക:

def sendwelcomeemail(user):
    User = get_user_model()
    html = open('{}/users/welcome_email.html'.format(settings.BASE_DIR)).read()
    subject = 'Welcome to ' + settings.SITE_NAME + ', {{ username }}!'
    template = Template(html)
    subjtemplate = Template(subject)
    context = Context({'username': user.username, 'base_url': settings.BASE_URL, 'model_name': 'Daisy Holton, 'site_name': settings.SITE_NAME})
    renderedtemplate = template.render(context)
    subjcontext = Context({'username': user.username})
    subjrenderedtemplate = subjtemplate.render(subjcontext)
    send_html_email(user, subjrenderedtemplate, renderedtemplate)

കൂടാതെ, ഈ വിവരങ്ങളെല്ലാം റെൻഡർ ചെയ്യുന്നതിന് ഞങ്ങൾക്ക് ഒരു ടെംപ്ലേറ്റ് ആവശ്യമാണ്. എന്റെ വെബ്സൈറ്റിൽ, ടെംപ്ലേറ്റ് ചുവടെയുള്ളത് പോലെ തോന്നുന്നു, പക്ഷേ നിങ്ങൾ ഇഷ്ടപ്പെടുന്നു.

ഞങ്ങൾക്ക് ബോഡി അല്ലെങ്കിൽ HTML ടാഗുകൾ അടയ്ക്കുന്നില്ല എന്നത് ശ്രദ്ധിക്കുക, കാരണം ഞങ്ങൾ HTML അൺസബ്സ്ക്രൈബുചെയ്യുമ്പോൾ ഇവ ചേർക്കുന്നു. ഇവ പ്രധാനമാണ്, പക്ഷേ അവരെ രണ്ടുതവണ നിർവചിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നില്ല.

അപ്പോൾ അടുത്തത് എന്താണ്? ഞങ്ങൾ ഒരുപാട് ദൂരം വന്നിരിക്കുന്നു. ശരിക്കും, സൈറ്റ് ഒരു സെർവറിലേക്ക് വിന്യസിക്കാൻ ഞങ്ങൾ തയ്യാറായിരിക്കണം. ഞങ്ങൾക്ക് @login_requird ഡെക്കറേറ്റർ ചേർത്ത് ഞങ്ങളുടെ കാഴ്ചപ്പാടുകൾ സുരക്ഷിതമാക്കുക, ഉപയോക്തൃ സൈൻഡുകൾ നേടുക, പ്രസക്തമായി തുടരാൻ ഒരു വെബ്സൈറ്റ് എന്തുചെയ്യാൻ ആവശ്യമായതിന്റെ അടിസ്ഥാനമാണ്. ഞങ്ങൾ കുറച്ച് ഉപയോഗപ്രദമായ സവിശേഷതകൾ ചേർത്ത് ഒരു വിദൂര സെർവറിലേക്ക് വിന്യസിക്കുന്നതിന് ഒരു അടിസ്ഥാനം നിർമ്മിക്കുക, ഞങ്ങളുടെ സൈറ്റ് സുരക്ഷിതവും ഉചിതവുമാക്കുന്നതിന് ഒരു മെയിൽ സെർവർ, ഡൊമെയ്ൻ കോൺഫിഗറേഷൻ, ഫിൽട്ടറുകൾ എന്നിവ സജ്ജമാക്കുക.

ഞങ്ങൾക്ക് പാസ്വേഡ് പുന reset സജ്ജമാക്കൽ കാഴ്ച ആവശ്യമാണ്, അതിനാൽ നമുക്ക് അത് വേഗത്തിൽ ചേർക്കാം. പാസ്വേഡ് പുന reset സജ്ജമാക്കൽ കാഴ്ചയിൽ നിർമ്മിച്ചിരിക്കുന്നത് ചില പ്രവർത്തനങ്ങളിൽ വ്യാവനമാണ്. ഉപയോക്താക്കൾ / views.py എന്നത് കാഴ്ച കാണപ്പെടുന്നത് ഇതാ

# ... ഇറക്കുമതി

ഈ ഫോം ക്ജങ്കോയിലേക്ക് നിർമ്മിച്ചിട്ടുണ്ട്, പക്ഷേ പാസ്വേഡ് പുന reset സജ്ജമാക്കൽ, ഉപയോക്താക്കൾ / ടെംപ്ലേറ്റുകൾ / ഉപയോക്താക്കൾ / പാസ്വേഡ് / പാസ്വേഡ്_രെസെറ്റ്_കോൺഫിർഎംഎംഎൽ എന്നിവ സ്ഥിരീകരിക്കുന്നതിന് ഞങ്ങൾക്ക് ഒരു ടെംപ്ലേറ്റ് ആവശ്യമാണ്

ഒരു ലളിതമായ ഫോം, ഉപയോക്താക്കൾ / ടെംപ്ലേറ്റുകൾ / ഉപയോക്താക്കൾ / ഉപയോക്താക്കൾ / പാസ്വേഡ്_അസെറ്റ്.

ഉപയോക്താവിനുള്ള ടെംപ്ലേറ്റ്, ഉപയോക്താക്കൾ / ടെംപ്ലേറ്റുകൾ / ഉപയോക്താക്കൾ / പാസ്വേഡ്_അമെയിൽ. ഈ ഫയൽ സ്വപ്രേരിതമായി വ്യാഖ്യാനിക്കും.

ഞങ്ങൾക്ക് രണ്ട് ടെംപ്ലേറ്റുകൾ ആവശ്യമാണ്. ഇമെയിൽ അയച്ചതായി സ്ഥിരീകരിക്കുക എന്നതാണ് ആദ്യത്തേത്. ഇവയ്ക്കായുള്ള കാഴ്ചകൾ ഇതിനകം തന്നെ ഡാങ്കോയിലാണ്, അതിനാൽ ഞങ്ങൾ അവയെ URLS.PY- ൽ അഭിസംബോധന ചെയ്യേണ്ടതുണ്ട്. ഉപയോക്താക്കൾ / ടെംപ്ലേറ്റുകൾ / ഉപയോക്താക്കൾ / പാസ്വേഡ്_രെസെറ്റ്_ഡോൺ. HTML- ൽ ഈ ടെംപ്ലേറ്റ് സ്ഥിതിചെയ്യുന്നു

അവസാനമായി, പാസ്വേഡ് പുന reset സജ്ജമാക്കൽ പൂർത്തിയായി, ഉപയോക്താക്കൾ / ടെംപ്ലേറ്റുകൾ / ഉപയോക്താക്കൾ / പാസ്വേഡ്_രെസെറ്റ്_കോംപ്ലെറ്റ്.എച്ച്എംഎൽ

ഇപ്പോൾ, ഈ കാഴ്ചകൾക്കായി ഞങ്ങൾക്ക് URL പാറ്റേണുകൾ ആവശ്യമാണ്. ഉപയോക്താക്കളിൽ / urls.py, ഇനിപ്പറയുന്ന URL പാറ്റേണുകൾ ചേർക്കുക:

    # ... മുമ്പത്തെ URL കൾ

നാല് ടെംപ്ലേറ്റുകൾ, അത് ഒരുപാട്! മാത്രമല്ല, വെബ് ബ്ര browser സറിൽ നിന്നുള്ളവയിൽ നിന്നും ഞങ്ങൾക്ക് എപ്പോൾ വേണമെങ്കിലും ഉപയോക്താവിന്റെ പാസ്വേഡ് പുന reset സജ്ജമാക്കാൻ ഞങ്ങൾക്ക് കഴിയുമെന്ന് ഉറപ്പാണ്.

ഇത് ഒരുപാട് കോഡ് ആണെന്ന് ഞാൻ മനസ്സിലാക്കുന്നു. അത് നിങ്ങളുടെ തലയിൽ അൽപ്പം തോന്നുന്നുവെങ്കിൽ, അത് ശരിയാണ്. നിങ്ങൾ മെച്ചപ്പെടും, നിങ്ങളുടെ ധാരണ മെച്ചപ്പെടും, നിങ്ങൾ ഉടൻ തന്നെ കോഡിനുമായി കൂടുതൽ കഴിവുള്ളവരാകും. നിങ്ങൾ പൂർണ്ണമായും നഷ്ടപ്പെട്ടാൽ, ഒരു സ്വയം-പാസഡ് പ്രവർത്തിച്ചതിന് ശേഷം പിന്നീട് പ്രവർത്തിക്കാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു. ഓൺലൈനിൽ കോഴ്സ് കോഡ് ചെയ്യാൻ പഠിക്കുക. ഇവ സാധാരണയായി ആരംഭിക്കാൻ സ്വാതന്ത്ര്യമുണ്ട്, നിങ്ങൾ ഈ പ്രോജക്റ്റിലേക്ക് മടങ്ങിവരുമ്പോൾ വിജയിക്കേണ്ടതെല്ലാം നിങ്ങളെ നയിക്കും. നിങ്ങൾ തുടരാൻ തയ്യാറാണെന്ന് തോന്നിയാൽ, അടുത്തതായി, നിങ്ങളുടെ കോഡ് ഒരു വിദൂര സെർവറിലേക്ക് വിന്യസിക്കുകയും ബാഷ് ഉപയോഗിച്ച് നിങ്ങളുടെ വിന്യാസം സജ്ജീകരിക്കുകയും ചെയ്യും, അതിനാൽ കുറച്ച് ലളിതമായ കമാൻഡുകൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും ഒരു പുതിയ പ്രോജക്റ്റ് സജ്ജീകരിക്കും.

ഒരു വിദൂര സെർവറിലേക്ക് വിന്യസിക്കുന്നതിന് മുമ്പ് നാം അവസാനമായി ചെയ്യേണ്ടത് ഞങ്ങളുടെ സൈറ്റിനെ കുറച്ചുകൂടി സുരക്ഷിതമാക്കുന്നു. ലോഗിൻ കാഴ്ച ഒരു ഉപയോക്തൃനാമവും പാസ്വേഡും മാത്രമേ എടുക്കാറുണ്ടെന്ന് നിങ്ങൾ ശ്രദ്ധിക്കും, കൂടാതെ മൾട്ടി ഫാക്ടർ പ്രാമാണീകരണമോ ഒറ്റത്തവണ കോഡോ ഇല്ല. ഇതൊരു എളുപ്പ പരിഹാരമാണ്, അതേ കോഡിനൊപ്പം, ഞങ്ങൾക്ക് ഞങ്ങളുടെ സൈറ്റ് വാചക സന്ദേശങ്ങൾ അയയ്ക്കാനും സെർവറിലേക്ക് അയച്ച വാചക സന്ദേശങ്ങളോട് പ്രതികരിക്കാനും കഴിയും. ആരംഭിക്കുന്നതിന്, ഞങ്ങൾ ഉപയോക്തൃ മോഡലുകളിലേക്ക് തിരികെ പോയി ഒരു ടൈംസ്റ്റാമ്പ് സൈനർ ചേർക്കുക, അത് ഓരോ ലോഗിൻയും പ്രതിനിധീകരിക്കുന്ന ഒരു ടൈംസ്റ്റാമ്പ് സൈനർ ചേർക്കും. ഞങ്ങളുടെ ലോഗിൻ അധിക സുരക്ഷ ചേർക്കാൻ ഉപയോഗിക്കുന്ന ഉപയോക്തൃ മാതൃകയിലും ഞങ്ങൾ ഒരു അദ്വിതീയമായി ചേർക്കുന്ന ഐഡന്റിഫയർ ചേർക്കും. ഉപയോക്തൃ മോഡലുകൾ എഡിറ്റുചെയ്യുന്നു, ഉപയോക്താക്കൾ / മോഡലുകൾ .പി, ഇനിപ്പറയുന്ന കോഡ് ചേർക്കുക:

# യുയുഐഡി, ടൈംസ്റ്റാമ്പ് സൈനർ, URL ജനറേറ്റർ (റിവേഴ്സ്) എന്നിവ ഇറക്കുമതി ചെയ്യുന്നത് ഉറപ്പാക്കുക
    # ഈ കോഡ് ഇവിടെ ചേർക്കുക
    # ഈ പ്രവർത്തനം ചേർക്കുക
            TimestampSigner().unsign(key, max_age=60 * settings.AUTH_VALID_MINUTES) # 3 മിനിറ്റ് സാധുവാണ്

നിങ്ങളുടെ ഉപയോക്താക്കൾ / മോഡലുകൾക്ക് ഇതുപോലെ തോന്നുന്നുവെന്ന് ഉറപ്പാക്കുക (# ഉള്ള വരികളിലെ കോഡ്). ഇത് തകർക്കുന്നു, അത് ലളിതമാണ്. ഞങ്ങൾക്ക് കുറച്ച് ഇറക്കുമതിയുണ്ട്, ഒരു ക്രിപ്റ്റോഗ്രാഫിക് യൂട്ടിലിറ്റിയാണ്, അത് ഒരു സുരക്ഷിത കോഡ് സൃഷ്ടിക്കാൻ കഴിയുന്ന ഒരു ക്രിപ്റ്റോഗ്രാഫിക് യൂട്ടിലിറ്റിയാണ്, അത് സാധുതയുള്ളതാണെന്ന് ഉറപ്പാക്കുന്നതിന് ഇത് സ്ഥിരീകരിച്ചു, ഒരു നിശ്ചിത എണ്ണം സെക്കൻഡിനേക്കാൾ പഴയതല്ല. ഞങ്ങൾ ഒരു യുയുഐഡിയും ഉപയോഗിക്കുന്നു, അത് ടോക്കണിന്റെ ഒപ്പിട്ടതിലും ടോക്കൺ ഉപയോക്താവിന് അയയ്ക്കുന്ന URL- ലും. രണ്ട് ഘടക പ്രാമാണീകരണ കാഴ്ച നിർമ്മിക്കുന്നതിന് ഞങ്ങൾ ഈ അടിസ്ഥാന ക്രിപ്റ്റോഗ്രാഫി ഉപയോഗിക്കും. ഞങ്ങൾ മറ്റെന്തെങ്കിലും ചെയ്യുന്നതിന് മുമ്പ്, നമുക്ക് മൈഗ്രേഷനുകൾ പ്രവർത്തിപ്പിക്കാം, അതിനാൽ ഞങ്ങളുടെ ഉപയോക്തൃ മോഡലുകൾ അപ്ഡേറ്റുചെയ്തു. മാനേജുള്ള ഡയറക്ടറിയിൽ, മൈഗ്രേഷനുകൾ നിർമ്മിക്കാനും പൂർത്തിയാക്കാനും ഇനിപ്പറയുന്ന കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുക.

source venv/bin/activate
python manage.py makemigrations && python manage.py migrate

ഇത് പ്രധാനമാണ്, കാരണം ഞങ്ങൾ മോഡലുകളിൽ മാറ്റങ്ങൾ വരുത്തുമ്പോഴെല്ലാം, ഞങ്ങൾ പട്ടികകൾ സൃഷ്ടിക്കുകയും സ്ഥിരസ്ഥിതികൾ സ്ഥിരസ്ഥിതികൾ ഉപയോഗിച്ച് അപ്ഡേറ്റ് ചെയ്യേണ്ടതുണ്ട്.

അടുത്തതായി, ഒരു ദ്വിതീയ പ്രാമാണീകരണ കാഴ്ചയിലേക്ക് റീഡയറക്ടുചെയ്യാൻ ഞങ്ങളുടെ ലോഗിൻ കാഴ്ച മെച്ചപ്പെടുത്തട്ടെ. ഉപയോക്താക്കളിൽ / views.py, ലോഗിൻ ഫംഗ്ഷൻ നീക്കംചെയ്ത് ഉപയോക്തൃ മോഡലുകളിൽ ഞങ്ങൾ സൃഷ്ടിച്ച URL റീഡയറക്ട് ചെയ്യുക.

# ... ഇറക്കുമതി
        if user and user.profile.can_login < timezone.now(): # ഉപയോക്താവിന് ലോഗിൻ ചെയ്യാൻ കഴിയുമോ എന്ന് ശ്രദ്ധിക്കുക
            # ഇവിടെയുള്ള auth_login പ്രവർത്തനം നീക്കംചെയ്യുക
                return redirect(user.profile.create_auth_url()) # കുറിപ്പ് ഞങ്ങൾ ഇവിടെ ഒരു പുതിയ URL ലേക്ക് റീഡയറക്ട് ചെയ്യുന്നു
            else: # ഉപയോക്താവ് മൾട്ടി-ഫാക്ടർ പ്രാമാണീകരണം ഉപയോഗിക്കുന്നില്ലെങ്കിൽ, അവ ലോഗിൻ ചെയ്യുക.
        else: # ലോഗിൻ വിജയിച്ചില്ലെങ്കിൽ,
            user = User.objects.filter(username=username).first() # ഉപയോക്താക്കൾ പ്രൊഫൈൽ അപ്ഡേറ്റ് ചെയ്യുന്ന ഭാഗം ഇതാണ്
                profile.can_login = timezone.now() + datetime.timedelta(seconds=15) # അതിനാൽ അവർക്ക് കുറച്ച് നിമിഷങ്ങൾ വീണ്ടും ലോഗിൻ ചെയ്യാൻ കഴിയില്ല

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

ആദ്യം, ഞങ്ങളുടെ കോഡിൽ നിന്ന് ഒരു വാചക സന്ദേശം അയയ്ക്കാൻ ഞങ്ങൾക്ക് ഒരു എളുപ്പ മാർഗം ആവശ്യമാണ്. ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾക്ക് നിരവധി API- കളിൽ നിന്ന് തിരഞ്ഞെടുക്കാം, പക്ഷേ എന്റെ അഭിപ്രായത്തിലെ ഏറ്റവും എളുപ്പമുള്ളത് ട്വിലിയോ ആണ്. ചെറിയ പ്രോജക്റ്റുകൾക്കും ബൾക്ക് കിഴിവുകൾക്കും അവർ നല്ല വിലനിർണ്ണയ വാഗ്ദാനം ചെയ്യുന്നു. Twilio.com- ൽ ഒരു അക്കൗണ്ട് സൃഷ്ടിക്കുക, നിങ്ങളുടെ പ്രോജക്റ്റിനെക്കുറിച്ചുള്ള ചില വിശദാംശങ്ങൾ പൂരിപ്പിക്കുക, ഒരു ഫോൺ നമ്പർ വാങ്ങുക, നിങ്ങളുടെ API കീകൾ നിങ്ങളുടെ ക്രമീകരണങ്ങൾ പകർത്തുക. തുടർന്ന്, ഒരു പുതിയ ഫയലിന് കീഴിൽ, ഉപയോക്താക്കൾ / sms.py എന്നിവ പ്രകാരം ഈ കോഡ് ചേർക്കുക.

nano users/sms.py

# ആവശ്യമായ എല്ലാ പാക്കേജുകളും ഇറക്കുമതി ചെയ്യുക
# ഈ കോഡ് ട്വിലിയോ ഉപയോഗിച്ച് വാചകം അയയ്ക്കുന്നു
# നിരവധി അക്കങ്ങളുള്ള ഒരു നമ്പർ ലഭിക്കുന്നതിനുള്ള ഒരു സഹായി പ്രവർത്തനം
# ഉപയോക്താവിനെ സ്ഥിരീകരിക്കുന്നതിന് വാചകം അയയ്ക്കുക
# ഈ ഫംഗ്ഷനുമായി ഒരു ഉപയോക്താവിനെ ഏതെങ്കിലും വാചകം അയയ്ക്കുക
# ഈ ഫംഗ്ഷൻ ഉപയോഗിച്ച് കോഡ് സാധൂകരിക്കുക
# സമയം സാധൂകരിക്കുക

നിങ്ങളുടെ ക്രമീകരണങ്ങൾ ഉചിതമായി മാറ്റുക, നിങ്ങളുടെ കീകൾ ഉപയോഗിച്ച് ഈ വരികൾ ചേർക്കുന്നത് ഉറപ്പാക്കുക:

# നിങ്ങളുടെ ട്വിലിയോ ഡാഷ്ബോർഡിൽ നിന്ന് ഇവ പകരുന്നത് ഉറപ്പാക്കുക
AUTH_VALID_MINUTES = 3 # മിനിറ്റുകളുടെ എണ്ണം TFA പേജ് ഇൻസ്റ്റാൾ ചെയ്തുകഴിഞ്ഞാൽ സജീവമാണ്

ആദ്യം, ഞങ്ങളുടെ രണ്ട് ഘടക പ്രാമാണീകരണ കാഴ്ചകൾക്കായി ഞങ്ങൾക്ക് ഫോമുകൾ ആവശ്യമാണ്. ഉപയോക്താക്കളെ / ഫോം. PI എഡിറ്റുചെയ്യുക, ഇനിപ്പറയുന്ന കോഡ് ചേർക്കുക.

# ... ഇറക്കുമതി
# ഞങ്ങളുടെ ഫോൺ നമ്പർ നൽകുന്നതിനുള്ള ഒരു ഫോം
# പ്രാമാണീകരിക്കുന്നതിനുള്ള ഒരു ഫോം

അടുത്തതായി, ഉപയോക്താക്കൾ / views.py- ലെ കാഴ്ചകൾ സൃഷ്ടിക്കാം

# ... ഇറക്കുമതി

ഈ രണ്ട് കാഴ്ചകൾക്കും ഞങ്ങൾക്ക് ടെംപ്ലേറ്റുകൾ ആവശ്യമാണ്. നമുക്ക് ആദ്യം MFA ടെംപ്ലേറ്റ് ചേർക്കാം.

nano users/templates/users/mfa.html

ടെംപ്ലേറ്റിലേക്ക് ഈ HTML കോഡ് ചേർക്കുക

ഇത് സ്വയം വിശദീകരിക്കുന്നതാണ്. ഫോം ഒരു കോഡ് അല്ലെങ്കിൽ ശൂന്യമായ കോഡ് അയയ്ക്കുന്നു, കൂടാതെ ഞങ്ങൾക്ക് ഒരു ശൂന്യമായ കോഡ് ലഭിക്കുകയാണെങ്കിൽ ഞങ്ങൾ കോഡ് അയയ്ക്കുന്നതായി നിങ്ങൾ ശ്രദ്ധിക്കും. അപ്പോൾ ഞങ്ങൾക്ക് രണ്ട് സമർപ്പിക്കൽ ബട്ടണുകൾ ഉണ്ട്, ഈ രീതിയിൽ ഞങ്ങൾക്ക് കോഡ് ഉപയോഗിച്ച് കോഡ് അയയ്ക്കാൻ കഴിയും. അടുത്തതായി, ഒരു ഫോൺ നമ്പർ ചേർക്കാൻ ഞങ്ങൾ ഒരു ലളിതമായ ഫോം ചേർക്കും.

nano users/templates/users/mfa_onboarding.html

ഇനിപ്പറയുന്ന HTML ചേർക്കുക:

ഈ ഫോം ഒരുപാട് ലളിതമാണ്, ഇത് ഞങ്ങൾ സൃഷ്ടിച്ച ഫോൺ നമ്പർ ഫോം റെൻഡർ ചെയ്യുകയും ഉപയോക്താവിനെ ഒരു ഫോൺ നമ്പർ ചേർക്കുകയും ചെയ്യുന്നു.

ഇത് വളരെ നല്ലതായി തോന്നുന്നു! എല്ലാം ശരിയായി സജ്ജീകരിച്ചിരിക്കുന്നിടത്തോളം കാലം, ഞങ്ങൾക്ക് സന്ദേശങ്ങൾ അയയ്ക്കാൻ കഴിയണം, ഞങ്ങൾ URL പാറ്റേണുകൾ ചേർക്കുന്നതിനൊപ്പം ഉപയോക്താവിനെ അവരുടെ ഫോൺ നമ്പർ ഉപയോഗിച്ച് ലോഗിൻ ചെയ്യുക. ഞങ്ങൾ സജ്ജീകരിക്കേണ്ടത് ഒരു പ്രൊഫൈൽ കാഴ്ചയാണ്, അതിനാൽ ഉപയോക്താവിന് ലോഗിൻ ചെയ്യാതെ ഉപയോക്താവിന് അവരുടെ ഫോൺ നമ്പർ മാറ്റാൻ കഴിയുമെന്ന് നമുക്ക് ഉറപ്പുണ്ടായിരിക്കാം. കൂടാതെ, ഭാവിയിലെ വാചക സന്ദേശങ്ങൾ ഒഴിവാക്കാൻ ഉപയോക്താവിന് "നിർത്താൻ" കഴിയും.

ഉപയോക്താക്കൾക്ക് / കാഴ്ചകൾ .പിഡിക്ക് ഒരു പ്രൊഫൈൽ കാഴ്ച ചേർക്കാം. ഈ കാഴ്ച ഉപയോക്താവിന്റെ ബയോ, ഇമെയിൽ, ഉപയോക്തൃനാമം, ഫോൺ നമ്പർ എന്നിവ അപ്ഡേറ്റ് ചെയ്യും, അതുപോലെ തന്നെ മൾട്ടി ഫാക്ടർ പ്രാമാണീകരണം പ്രാപ്തമാക്കുന്നതിന് ഞങ്ങളെ അനുവദിക്കുക. ആദ്യം, ഉപയോക്താക്കൾക്ക് / ഫോം. PY ഞങ്ങൾക്ക് രണ്ട് ഫോമുകൾ കൂടി ആവശ്യമാണ്

# ... ഇറക്കുമതി

അടുത്തതായി, ഈ രണ്ട് രൂപങ്ങളും ഉപയോഗിക്കാൻ ഞങ്ങൾക്ക് ഒരു കാഴ്ച സൃഷ്ടിക്കാൻ കഴിയും. ഉപയോക്താക്കളെ എഡിറ്റുചെയ്യുക / views.py ചെയ്ത് കാഴ്ചയിൽ ചേർക്കുക.

# ഈ ഇറക്കുമതി ചേർക്കുക

ഈ കാഴ്ചയ്ക്കായി ഞങ്ങൾക്ക് ഒരു ടെംപ്ലേറ്റ് ആവശ്യമാണ്.

nano users/templates/users/profile.html

ഇത് വളരെ ലളിതമായ ഒരു രൂപമാണെന്ന് നിങ്ങൾ ശ്രദ്ധിക്കുന്നു, പക്ഷേ അതിൽ ചില ജാവാസ്ക്രിപ്റ്റ് ഉണ്ട്, അത് ഫോമിന്റെ ഉള്ളടക്കങ്ങൾ അപ്ഡേറ്റ് ചെയ്യുമ്പോൾ സ്വപ്രേരിതമായി പോസ്റ്റുചെയ്യുന്നു. ഇത് ലഭിക്കുന്നത് ഉപയോഗപ്രദമാണ്, അതിനാൽ ഓരോ തവണയും സമർപ്പിക്കാതെ നിങ്ങൾക്ക് എഡിറ്റുകൾ നിർമ്മിക്കാൻ കഴിയും.

അടുത്തതായി, ഉപയോക്താക്കളുടെ URL പാറ്ററുകൾക്കായുള്ള ഈ വീക്ഷണങ്ങളെ പ്രതിനിധീകരിക്കുന്ന URL കൾ ഞങ്ങൾക്ക് ആവശ്യമാണ്. ഉപയോക്താക്കൾ / urls.py എഡിറ്റുചെയ്ത് ഈ കോഡ് ചേർക്കുക:

# ... മുമ്പത്തെ കോഡ്, ഇറക്കുമതി
# ... ഞങ്ങൾ മുമ്പ് നൽകിയ URL പാറ്റേണുകൾ, അടുത്ത മൂന്ന് വരികൾ ചേർക്കുക

ഞങ്ങളുടെ പ്രോജക്റ്റ് പരീക്ഷിക്കാൻ ഇപ്പോൾ ഒരു നല്ല സമയമാണ്. എന്നാൽ ആദ്യം, നമുക്ക് മറ്റൊരു ബാക്കപ്പ് പ്രവർത്തിപ്പിക്കാം.

backup

സെർവർ പ്രവർത്തിപ്പിക്കുക. ഞങ്ങൾ ഒരു ലിനക്സ് സെർവറിലേക്ക് വിന്യസിക്കുന്നതിന് മുമ്പ്, അക്കൗണ്ടിൽ രണ്ട് ഘടക പ്രാമാണീകരണം പ്രാപ്തമാക്കുന്നത് നല്ലതാണ്. ഞങ്ങളുടെ പ്രൊഫൈൽ URL, / ഉപയോക്താക്കൾ / പ്രൊഫൈൽ /, ഞങ്ങളുടെ ഫോൺ നമ്പറിൽ പ്രവേശിച്ചതിന് ശേഷം ഞങ്ങൾ ഇത് നിങ്ങളുടെ പ്രൊഫൈൽ URL, / ഉപയോക്താക്കൾ / പ്രൊഫൈൽ /, എന്നിവയിലേക്ക് പോകും, ​​തുടർന്ന് ഫോം സമർപ്പിക്കുക.

python manage.py runserver localhost:8000

നിങ്ങളുടെ വെബ് ബ്ര browser സറിലേക്ക് പോയി ഞാൻ ഈ ഉദാഹരണത്തിൽ Google Chrome സന്ദർശിച്ച് URL HTTPS: 8000 / അക്കൗണ്ടുകൾ / പ്രൊഫൈൽ /

ആവശ്യമെങ്കിൽ നിങ്ങൾക്ക് ലോഗിൻ ചെയ്യാനും രണ്ട് ഘടക പ്രാമാണീകരണം പ്രാപ്തമാക്കാനും കഴിയും.

ഈ പ്രോജക്റ്റിന് പ്രവർത്തിക്കാൻ ഒരു സെർവർ ആവശ്യമാണ്, അതിനാൽ ഇത് ശരിക്കും മെയിൽ അയയ്ക്കാൻ കഴിയും. എന്നാൽ ആദ്യം, പിശകുകൾ കാണാനുള്ള ഒരു മാർഗം ആവശ്യമാണ്. ഡീബഗ് മോഡിൽ നിങ്ങൾ സെർവർ പ്രവർത്തിപ്പിച്ചാൽ, ക്രമീകരണങ്ങൾ. ട്രൂവിന് തുല്യമായത്, സെർവർ യാന്ത്രികമായി കാണിക്കുന്നു. ഡീബഗ് മോഡ് ഉപയോഗിക്കാതെ പിശകുകൾ കാണിക്കുന്നതിന്, അത് ഒരു പ്രൊഡക്ഷൻ സെർവറിൽ സുരക്ഷിതമല്ല, ഞങ്ങൾ അതിനായി ഒരു കാഴ്ച ചേർക്കണം. നമുക്ക് കൈകാര്യം ചെയ്യാൻ കഴിയുന്ന ഏറ്റവും പ്രധാനപ്പെട്ട പിശകുകൾ ഇവയാണ്:

പിശക് 500 - ഞങ്ങളുടെ കോഡിലെ ഒരു പ്രശ്നം പിശക് 404 - കണ്ടെത്തിയിട്ടില്ലാത്ത ഒരു പേജ് (തകർന്ന URL) പിശക് 403 - ഒരു അനുമതി പിശക് നിരസിച്ചു

പിശകുകൾ എന്ന് വിളിക്കുന്ന ഈ പിശകുകൾ കൈകാര്യം ചെയ്യുന്നതിന് ഒരു പുതിയ അപ്ലിക്കേഷൻ ചേർക്കാം.

python manage.py startapp errors

ഞങ്ങൾ മുമ്പ് ചെയ്തതുപോലെ, ഇൻസ്റ്റാൾ ചെയ്ത_അപ്പ് ക്രമീകരണത്തിൽ ഇത് ചേർത്ത് ആരംഭിക്കുക, അപ്ലിക്കേഷൻ / urls.py- ലെ ചില കാഴ്ചപ്പാടുകളിലേക്ക് റഫറൻസുകൾ ചേർത്തുകൊണ്ട് ആരംഭിക്കുക, അവിടെ നിങ്ങളുടെ ഡാങ്കോ പ്രോജക്റ്റിന്റെ പേരാണ് അപ്ലിക്കേഷൻ.

handler404 = 'errors.views.handler404'
handler500 = 'errors.views.handler500'
handler403 = 'errors.views.handler403'

പിശക് കാഴ്ചകൾ, ടെംപ്ലേറ്റുകൾ, കുറച്ച് മധ്യവ്യവ്യങ്ങൾ എന്നിവ കൂടാതെ ഞങ്ങൾക്ക് ആവശ്യമാണ്. അങ്ങനെയുള്ളവരെ നിർവചിക്കാം:

# നിങ്ങളുടെ കാഴ്ചകൾ ഇവിടെ സൃഷ്ടിക്കുക.

അടുത്തതായി, ഈ പിശകുകൾ കൈകാര്യം ചെയ്യാൻ മിഡിൽവെയർ നിർവചിക്കാം. ഞങ്ങളുടെ മിഡിൽവെയറിന്റെ പേരിലുള്ള ക്രമീകരണങ്ങൾ.

    # ... മുമ്പത്തെ മിഡിൽവെയർ

അടുത്തതായി, നമുക്ക് മധ്യവെയർ ചേർക്കാം.

from threading import local
import traceback
from django.utils.deprecation import MiddlewareMixin

_error = local()

class ExceptionVerboseMiddleware(MiddlewareMixin):
    def process_exception(self, request, exception):
        _error.value = traceback.format_exc()

def get_current_exception():
    try:
        return _error.value
    except AttributeError:
        return None

def set_current_exception(exception):
    try:
        _error.value = exception
    except AttributeError:
        print('Attribute error setting exception.')

ഒരു ത്രെഡ് ലോക്കൽ ഉപയോഗിച്ച് നിലവിലെ ഒഴിവാക്കൽ ലഭിക്കുന്നതിന് ഞങ്ങൾ ഒരു പ്രവർത്തനം ചേർക്കുന്നു, ഇത് ഞങ്ങളുടെ കോഡിൽ എന്തെങ്കിലും പിശകുകൾ കണ്ടെത്താൻ സഹായിക്കുന്നു. ടെംപ്ലേറ്റുകളുടെ കാര്യത്തിൽ, ഞങ്ങൾക്ക് ഒന്ന് മാത്രമേ ആവശ്യമുള്ളൂ, കാരണം ഞങ്ങൾ കാഴ്ചയിലെ ശീർഷകം മാത്രം ധനികരമായി നിർവചിക്കുന്നു. ടെംപ്ലേറ്റ് ശീർഷകവും "ട്രെയ്സും" റെൻഡർ ചെയ്യേണ്ടതുണ്ട്, സന്ദർഭത്തിൽ നിന്നുള്ള ഞങ്ങളുടെ പിശക് ട്രേസ്ബാക്ക്.

nano errors/templates/errors/error.html

ഇതാണ് ഞങ്ങളുടെ ഏറ്റവും ലളിതമായ ടെംപ്ലേറ്റ്, പക്ഷേ ഞങ്ങളുടെ പ്രോജക്റ്റിലെ പിശകുകൾ കാണുന്നത് എത്ര എളുപ്പമാണ്. അടുത്തതായി, ക്രമീകരണങ്ങളിൽ ഡീബഗ് അപ്രാപ്തമാക്കാം.

nano app/settings.py

അത് ശരിയായി സജ്ജമാക്കിയിരിക്കുന്ന ഈ വരി കണ്ടെത്തുക, അത് തെറ്റായി മാറ്റുക

DEBUG = False

മുന്നോട്ട് പോയി അപ്ലിക്കേഷൻ ബാക്കപ്പ് ചെയ്യുക. ഒരു വിദൂര ലിനക്സ് സെർവറിലേക്ക് വിന്യസിക്കാനും അവിടെ നിന്ന് സവിശേഷതകൾ ചേർക്കാനും ഞങ്ങൾ തയ്യാറാണ്.

sudo backup

ഞങ്ങൾ ഈ കോഡ് ഒരു സെർവറിലേക്ക് പോസ്റ്റുചെയ്യുന്നതിന് മുമ്പ്, കോഡിനൊപ്പം ചില പ്രശ്നങ്ങളുണ്ടാകാമെന്ന് നാം പരിഗണിക്കണം. കേസ് അനുസരിച്ച്, അവയിൽ പോസ്റ്റുചെയ്യുന്ന സൈറ്റുകൾക്ക് സ്പാം ഉള്ള പ്രശ്നങ്ങളുണ്ടാകും സ്പാം പോസ്റ്റുചെയ്യുന്നതും സ്പാം നീക്കംചെയ്യുന്നതും ബുദ്ധിമുട്ടാക്കും. ഇത് ഉടൻ സംഭവിക്കരുത്, പക്ഷേ അത് സംഭവിക്കുകയാണെങ്കിൽ, സൈറ്റ് ആക്സസ് ചെയ്യുന്നതിന് റോബോട്ടുകളെയും സൈറ്റ് ആക്സസ് ചെയ്യുന്നതിനും അല്ലെങ്കിൽ ഒരു ഫൈസേഷൻ അല്ലെങ്കിൽ ഫേഷ്യൽ അംഗീകാരം ഉപയോഗിച്ച് ഒരു ഉപയോക്താവിന്റെ ഐഡന്റിറ്റി പരിശോധിക്കുകയും ചെയ്യും.

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

nano users/models.py

നമ്മൾ ചേർക്കുന്നത് ഇതുപോലെയായിരിക്കണം. ഞങ്ങൾക്ക് ഒരു രീതികളും ആവശ്യമില്ല, ഒരു ഐഡി, ഉപയോക്താവ്, ടൈംസ്റ്റാമ്പ്, കാലഹരണപ്പെടൽ, ഏതെങ്കിലും മൾട്ടി ഫാക്ടർ പ്രാമാണീകരണത്തിനെതിരായ ശ്രമങ്ങൾ (123456 പോലുള്ള ഒരു കോഡ് ഒരു ഫോണിലേക്കോ ഇമെയിലിലേക്കോ അയച്ചു).

# വെബ്സൈറ്റിലേക്ക് ലോഗിൻ ചെയ്യാൻ ഉപയോഗിക്കുന്ന അടിസ്ഥാന ടോക്കൺ

ഞങ്ങളുടെ ഉപയോക്താവിനുള്ള ഒരു പദവിയും ചേർക്കാം, ഒടുവിൽ ഞങ്ങൾ അത് സ്വമേധയാ സജ്ജീകരിക്കും, മുമ്പ് പ്രത്യേകാവകാശ ഉപയോക്താക്കളെ സ്വപ്രേരിതമായി മാറ്റുന്നതിന് മുമ്പ് ഞങ്ങൾ അത് സ്വമേധയാ സജ്ജീകരിക്കും. ഉപയോക്തൃ മോഡലുകളിൽ, പ്രൊഫൈലിൽ ഈ ലൈൻ ചേർക്കുക:

    vendor = models.BooleanField(default=False)

ഡാറ്റാബേസിൽ എന്തെങ്കിലും മാറ്റങ്ങൾ വരുത്തിയതിനാൽ, ഞങ്ങൾ എപ്പോൾ വേണമെങ്കിലും ഡാറ്റാബേസ് മൈഗ്രേറ്റ് ചെയ്യേണ്ടതുണ്ട്. ഓർമ്മിക്കുക, ഞങ്ങൾ ആദ്യം ഉറവിടം ഉപയോഗിക്കുന്നു (ടെർമിനൽ തുറന്നിട്ട് മുമ്പ് ഇത് ഇതിനകം ഉപയോഗിച്ചിട്ടില്ലെങ്കിൽ, മൈഗ്രേഷനുകൾ നിർമ്മിക്കാനും മൈഗ്രേറ്റ് ചെയ്യാനും പൈത്തൺ മാനേജുചെയ്യുന്നു.

cd project-directory-you-named # (ആവശ്യമെങ്കിൽ)

ഇപ്പോൾ, ഷെൽ ഉപയോഗിച്ച് നിങ്ങൾ കച്ചവടമായി സൃഷ്ടിച്ച ഏതെങ്കിലും വിവരണങ്ങൾ ഉൾപ്പെടുത്താൻ നിങ്ങൾക്ക് കഴിയും.

python manage.py shell
from users.models import Profile
p = Profile.objects.get(user__username='Charlotte')
p.vendor = True
p.save()
exit()

ഇപ്പോൾ, ഈ ടോക്കൺ ഉപയോഗിക്കുന്നതിന് ഞങ്ങളുടെ മൾട്ടി ഫാക്ടർ പ്രാമാണീകരണ കാഴ്ച നമുക്ക് പരിണമിപ്പിക്കാം. ആദ്യം, ഞങ്ങളുടെ MFA ഹെൽപ്പർ യൂട്ടിലിറ്റികൾ പരിഷ്ക്കരിക്കേണ്ടതുണ്ട്. നാനോ ഉപയോഗിച്ച്,

nano users/mfa.py

from django.utils import timezone
import random
import datetime
from django.conf import settings
from feed.middleware import get_current_request
from django.contrib import messages
from .email import send_html_email
import traceback
from .models import MFAToken

account_sid = settings.TWILIO_ACCOUNT_SID
auth_token = settings.TWILIO_AUTH_TOKEN
source_phone = settings.PHONE_NUMBER

def send_text(target_phone, text):
    from twilio.rest import Client
    try:
        client = Client(account_sid, auth_token)
        if len(target_phone) >= 11:
            message = client.messages.create(
                to=target_phone,
                from_=source_phone,
                body=text + ' Text STOP to cancel.')
    except:
        messages.warning(get_current_request(), 'There was an error sending the message.')
        print(traceback.format_exc())

def get_num_length(num, length):
    n = ''
    for x in range(length):
        n = n + str(num)
    return int(n)

def send_verification_text(user, token):
    length = user.profile.verification_code_length
    code = random.randint(get_num_length(1, length), get_num_length(9, length));
    token.token = code
    token.expires = timezone.now() + datetime.timedelta(minutes=settings.AUTH_VALID_MINUTES)
    token.save()
    send_user_text(user, "Your verification code for {} is {}".format(settings.SITE_NAME, str(code)))

def send_verification_email(user, token):
    length = user.profile.verification_code_length
    code = random.randint(get_num_length(1, length), get_num_length(9, length));
    token.token = code
    token.expires = timezone.now() + datetime.timedelta(minutes=settings.AUTH_VALID_MINUTES)
    token.save()
    send_html_email(user, "Your verification code for {} is {}".format(settings.SITE_NAME, str(code)), "<p>Dear {},</p><p>Your verification code for {} is {}. Thank you for using this code to secure your account.</p><h2>{}</h2><p>Sincerely, {}</p>".format(user.profile.name, settings.SITE_NAME, str(code), str(code), settings.SITE_NAME))

def send_user_text(user, text):
    send_text(user.profile.phone_number, text)

def check_verification_code(user, token, code):
    token.attempts = token.attempts + 1
    profile = user.profile
    result = (token != None and code != '' and token.token == code and (token.expires > timezone.now()) and token.attempts <= settings.MFA_TOKEN_ATTEMPTS)
    if token.attempts < 3 and result:
        profile.verification_code_length = 6
    elif token.attempts > 1 and not result:
        profile.verification_code_length = profile.verification_code_length + 2
        if profile.verification_code_length > settings.MFA_TOKEN_LENGTH: profile.verification_code_length = settings.MFA_TOKEN_LENGTH
    token.save()
    profile.save()
    return result

# ഉപയോക്താവിനെ അവരുടെ ഇമെയിൽ അല്ലെങ്കിൽ ഫോൺ നമ്പർ ഉപയോഗിച്ച് പ്രാമാണീകരിക്കുക
    token = MFAToken.objects.filter(uid=username, expires__gt=timezone.now() + datetime.timedelta(seconds=30)).order_by('-timestamp').last() # URL- ൽ പാസാക്കിയ മൂല്യത്തിലൂടെ ടോക്കൺ ഫിൽട്ടർ ചെയ്യുക (ഒരു uuid)
    if not token: token = MFAToken.objects.create(user=User.objects.filter(profile__uuid=username).first(), uid=username, expires=timezone.now() + datetime.timedelta(seconds=115)) # ഈ സെഷൻ സൃഷ്ടിച്ചിട്ടില്ലെങ്കിൽ, അത് സൃഷ്ടിക്കുക
    user = User.objects.filter(id=token.user.id).first() # ടോക്കണിൽ നിന്ന് ഉപയോക്താവിനെ നേടുക
    if not user and request.user.is_authenticated: return redirect(reverse('feed:home')) # അവ ഇതിനകം പ്രാമാണീകരിച്ചിട്ടുണ്ടെങ്കിൽ അവ പ്രവേശിക്കുക
    if not user: raise PermissionDenied() # ഒരു ഉപയോക്താവും കണ്ടെത്തിയില്ലെങ്കിൽ നിരസിക്കുക
    if not user.profile.enable_two_factor_authentication and user.is_active and user.profile.check_auth_token(usertoken, token): # മൂവേറിയ ടോക്കൺ പരിശോധിക്കുക
        auth_login(request, user, backend='django.contrib.auth.backends.ModelBackend') # ഇതിനകം ലോഗിൻ ചെയ്തിട്ടില്ലെങ്കിൽ ഉപയോക്താവിൽ പ്രവേശിക്കുക
        user.profile.mfa_expires = timezone.now() + datetime.timedelta(minutes=settings.LOGIN_VALID_MINUTES) # അവരുടെ മൾട്ടി ഫാക്ടർ പ്രാമാണീകരണത്തിൽ ഒരു കാലഹരണപ്പെടൽ സജ്ജമാക്കുക
        return HttpResponseRedirect(next if next != '' else reverse('landing:landing')) # അടുത്ത പേജിലേക്ക് ഉപയോക്താവിനെ റീഡയറക്ട് ചെയ്യുക
    if not user.profile.mfa_enabled: # MFA പ്രാപ്തമാക്കിയിട്ടുണ്ടോയെന്ന് പരിശോധിക്കുക
        if not check_verification_time(user, token): # സമയം പരിശോധിക്കുക
            user.profile.mfa_enabled = False # ഫോൺ നമ്പർ മായ്ക്കുക
            user.profile.enable_two_factor_authentication = True # MFA പ്രാപ്തമാക്കുക
            user.profile.phone_number = '+1' # ഫോൺ നമ്പർ അപ്രാപ്തമാക്കുക
            user.profile.save() # പ്രൊഫൈൽ സംരക്ഷിക്കുക
            auth_login(request, user, backend='django.contrib.auth.backends.ModelBackend') # അവരുടെ MFA പ്രാപ്തമാക്കിയിട്ടില്ലെങ്കിൽ ഉപയോക്താവിനെ ലോഗിൻ ചെയ്യുക
    if request.method == 'POST' and not fraud_detect(request, True): # അഭ്യർത്ഥന ഒരു പോസ്റ്റ് അഭ്യർത്ഥനയാണെങ്കിൽ
        form = TfaForm(request.POST) # ഫോം ഇൻസ്റ്റാൾ ചെയ്യുക
        code = str(form.data.get('code', None)) # കോഡ് നേടുക
        if code and code != '' and code != None: # ഇത് ശൂന്യമല്ലെന്ന് ഉറപ്പാക്കുക
            token_validated = user.profile.check_auth_token(usertoken) # മൂവേറിയ ടോക്കൺ പരിശോധിക്കുക
            is_verified = check_verification_code(user, token, code) # കോഡ് പരിശോധിക്കുക
            if token_validated: # എല്ലാം ഉണ്ടെങ്കിൽ
                if is_verified: # ക്രമത്തിലാണ്
                    user.profile.mfa_enabled = True # MFA പ്രാപ്തമാക്കുക (ഇതിനകം പ്രവർത്തനക്ഷമമാക്കിയിട്ടില്ലെങ്കിൽ)
                    auth_login(request, user, backend='django.contrib.auth.backends.ModelBackend') # ഉപയോക്താവിൽ പ്രവേശിക്കുക
                    for key, value in request.GET.items(): # അടുത്ത പാരാമീറ്ററിനായി ഒരു അന്വേഷണ കെട്ടിപ്പടുക്കുക (എന്തെങ്കിലും ഉണ്ടെങ്കിൽ)
                        return HttpResponseRedirect(next) # മടക്കിക്കളയുക
            elif not token_validated: # ടോക്കൺ അസാധുവായിരുന്നുവെങ്കിൽ
            if p.mfa_attempts > 3: # വളരെയധികം ശ്രമങ്ങളുണ്ടെങ്കിൽ
            if form.data.get('send_email', False): # ഇമെയിൽ അയയ്ക്കുക (അല്ലെങ്കിൽ വാചകം)
    # ഫോം റെൻഡർ ചെയ്യുക (അഭ്യർത്ഥനകൾ ലഭിക്കുന്നതിന്)

ഞങ്ങൾ ഈ കോഡിൽ ചേർക്കുമ്പോൾ, ഒരു ഇമെയിൽ അയയ്ക്കാൻ ഫംഗ്ഷൻ ഇറക്കുമതി ചെയ്യുന്നത് ഉറപ്പാക്കുക. ഫയലിന്റെ മുകളിൽ, ഉപയോക്തൃ കാഴ്ചകൾ (മറ്റ് ഇറക്കുമതിയുമായി), ചേർക്കുക

from .mfa import send_verification_email as send_mfa_verification_email

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

nano users/mfa.py

def send_verification_email(user, token):
    length = user.profile.verification_code_length
    code = random.randint(get_num_length(1, length), get_num_length(9, length));
    token.token = code
    token.expires = timezone.now() + datetime.timedelta(minutes=settings.AUTH_VALID_MINUTES)
    token.save()
    send_html_email(user, "Your verification code for {} is {}".format(settings.SITE_NAME, str(code)), "<p>Dear {},</p><p>Your verification code for {} is {}. Thank you for using this code to secure your account.</p><h2>{}</h2><p>Sincerely, {}</p>".format(user.profile.name, settings.SITE_NAME, str(code), str(code), settings.SITE_NAME))

അതിനാൽ ഇതെല്ലാം മികച്ച രീതിയിൽ പ്രവർത്തിക്കുന്നു, ഇപ്പോൾ ലോഗിൻ ചെയ്യുന്നതിന് ഒരു ഫോൺ നമ്പറോ ഇമെയിലോ ആശ്രയിക്കുന്ന ഒരു മൾട്ടി ഫാക്ടർ പ്രാമാണീകരണ സംവിധാനം ഉണ്ട്. ഇവ സ്പാമർമാർ, റോബോട്ടുകൾ അല്ലെങ്കിൽ ഞങ്ങളുടെ ജോലിക്ക് നന്നായി അർത്ഥമില്ലാത്ത ആരെങ്കിലും ആകാം. എന്റെ വെബ്സൈറ്റിൽ ഉപയോക്താക്കളെ നിരീക്ഷിക്കുന്നതിനുള്ള ഒരു കാഴ്ച നോക്കുക:

# ഇറക്കുമതി
from .tests import is_superuser_or_vendor # ഈ പരീക്ഷണം ഞങ്ങൾ സൃഷ്ടിക്കേണ്ടതുണ്ട്
    # ഉപയോക്താക്കളുടെ പട്ടിക നേടുക
    return render(request, 'users/users.html', { # ഒരു ടെംപ്ലേറ്റിലെ ഉപയോക്താക്കളെ തിരികെ നൽകുക

ഈ കോഡ് ഒരു പരീക്ഷണം ഉപയോഗിക്കുന്നുവെന്നത് ശ്രദ്ധിക്കുക, ഞങ്ങൾ ഒരു ടെസ്റ്റ് ഫയലിൽ ഈ പരിശോധന പ്രഖ്യാപിക്കുകയും ഇറക്കുമതി ചെയ്യുകയും ചെയ്യും. ഉപയോക്താക്കളെ / ടെസ്റ്റുകൾ എഡിറ്റുചെയ്യുന്നു, നമുക്ക് പരിശോധന സൃഷ്ടിക്കാം.

def is_superuser_or_vendor(user):
    return user.profile.vendor or user.is_superuser

ഇത് ഉപയോക്താക്കളുമായി / ഉപയോക്താക്കളുമായി ചേർന്നാണ്. Html ടെംപ്ലേറ്റ്, ഇത് ഇതുപോലെ തോന്നുന്നു:

ടെംപ്ലേറ്റിൽ മറ്റൊരു ടെംപ്ലേറ്റ്, ഉപയോക്താക്കൾ /user.html. ഒരു ടെംപ്ലേറ്റ് ഉപയോഗിക്കുമ്പോൾ, വിപുലീകരിക്കപ്പെടാത്തതും വിപുലീകരിക്കപ്പെടാത്തതും, ഒരു അടിവരയിടുന്നത് ഒരു നല്ല ആശയമാണ് () ടെംപ്ലേറ്റുകളെ വേർതിരിച്ചറിയാൻ ഫയലിന്റെ പേരിന് മുമ്പ്.

ഇത് ധാരാളം ജിഞ്ചയാണെന്ന് ശ്രദ്ധിക്കുക, നിങ്ങൾ ഈ വേരിയബിളുകളെല്ലാം നിർവചിച്ചിരിക്കില്ല. എന്നാൽ ഇതാണ് എന്റെ കോഡ് ഇങ്ങനെ കാണപ്പെടുന്നത്.

      <small># {{User.id}} </ ചെറുത്>

ഞങ്ങൾക്ക് മറ്റൊരു സബ്ടംപ്ലേറ്റ്, ടോഗിൾ_ ആക്റ്റീവ്.എച്ച്എൽഎംഎൽ ആവശ്യമാണ്. ഒരു ഉപയോക്താവ് സജീവമാണെന്ന് ടോഗിൾ ചെയ്യാൻ ഈ ടെംപ്ലേറ്റ് ഒരു രൂപമായിരിക്കണം.

ഉപയോക്തൃ പ്രവർത്തനവും ഉചിതമായ URL പാറ്റേണുകളും ടോഗിൾ ചെയ്യുന്നതിനും ഞങ്ങൾ ഒരു കാഴ്ചയും ചേർക്കേണ്ടതുണ്ട്. ഞങ്ങൾ അതിലുണ്ടെങ്കിലും, അത് ആവശ്യമെങ്കിൽ ഒരു ഉപയോക്താവിനെ ഇല്ലാതാക്കാൻ ഒരു കാഴ്ച ചേർക്കാം.

# ഇറക്കുമതി
    success_url = '/' # വിജയ URL- ലെ റീഡയറക്ട്
    def test_func(self): # ഉപയോക്താവ് സൂപ്പർയൂസേർ ആണെങ്കിൽ ഇല്ലാതാക്കാൻ അനുമതി ഉണ്ടെങ്കിൽ

ഇത് പ്രായോഗികമായി ചെയ്യുമ്പോൾ, ഒരു ഉപയോക്താവിനെ ഇല്ലാതാക്കാൻ മിക്കപ്പോഴും ഇല്ലാതാക്കേണ്ടതില്ലെങ്കിൽ, അവ നിരസിക്കുകയാണെങ്കിൽ, ഞങ്ങൾ അവരെ പിരിച്ചുവിടേണമെങ്കിൽ സൈറ്റ് സന്ദർശിക്കുന്ന ഉപയോക്താക്കളുടെ ദൃശ്യപരത ടോഗിൾ ചെയ്യാൻ കഴിയും.

ഞങ്ങൾ ചേർത്ത URL പാറ്റേണുകൾ ഇതുപോലെ കാണപ്പെടുന്നു. നാനോ ഉപയോഗിച്ച്, ഉപയോക്താക്കളെ എഡിറ്റുചെയ്യുക / urls.py എഡിറ്റുചെയ്യുക, ഈ വരികൾ ചേർക്കുക:

nano users/urls.py

വരികൾ "]"] "]"] എന്നാൽ തുടക്കത്തിനുശേഷം "["] "[" ["]

# ...
# ...

ഇപ്പോൾ, സൈറ്റ് ബാക്കപ്പ് ചെയ്യുന്നത് ഉറപ്പാക്കുക, അതുവഴി ഞങ്ങൾ ഇത് തുടരുന്നത് തുടരുമെന്ന് നിങ്ങൾക്ക് ഇത് ഡ download ൺലോഡ് ചെയ്യാൻ കഴിയും. കമാൻഡ് ലൈനിൽ നിന്ന്,

sudo backup

ഇപ്പോൾ ഞങ്ങളുടെ സൈറ്റ് ബാക്കപ്പ് ചെയ്തിരിക്കുന്നു.

അതിനാൽ ഇപ്പോൾ ഞങ്ങൾക്ക് കുറച്ച് ഉപയോഗപ്രദമായ സവിശേഷതകളുണ്ട്. എന്നാൽ ഇവിടെ വലിയ ചിത്രത്തിന്റെ കാര്യമോ? ഈ കോഡ് ഇപ്പോഴും ഇന്റർനെറ്റിൽ നിന്ന് ആക്സസ് ചെയ്യാനാകില്ല, ഞങ്ങൾക്ക് ഇതുവരെ മെയിൽ സെർവറും ഇല്ല, ഒപ്പം ഞങ്ങളുടെ അപ്ലിക്കേഷൻ വിപുലീകരിക്കാൻ ഞങ്ങൾ സഹായിക്കേണ്ടതുണ്ട്, ഒപ്പം സ്വകാര്യ പ്രോട്ടോക്കോളുകളും

ഇതിലെല്ലാം ഞങ്ങൾ ലഭിക്കും. ഇപ്പോൾ ഏറ്റവും പ്രധാനപ്പെട്ട കാര്യം ഓൺലൈനിൽ ഈ കോഡ് ഓൺലൈനിൽ ലഭിക്കും, അത് ഒരു ഉബുണ്ടു സെർവറിൽ കുറച്ച് വരികൾ ബാഷ് ഉപയോഗിച്ച് ചെയ്യാൻ കഴിയും. നിങ്ങൾ വീട്ടിൽ ഒരു സെർവറും തുറമുഖങ്ങൾ തുറക്കാൻ അനുവദിക്കുന്ന ഒരു ബിസിനസ് ഇന്റർനെറ്റ് സബ്സ്ക്രിപ്റ്റും നിങ്ങൾ ഒരു സെർവർ വാടകയ്ക്കെടുക്കേണ്ടതുണ്ട്. എന്റെ അപ്പാർട്ട്മെന്റിൽ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുള്ള ഒരു എച്ച്പി Z440 ൽ ഞാൻ വ്യക്തിപരമായി പ്രവർത്തിപ്പിക്കുന്നു, പക്ഷേ ഇത് സാധാരണയായി ഒരു വെർച്വൽ പ്രൈവറ്റ് സെർവർ (വിപിഎസ്) വാടകയ്ക്കെടുക്കേണ്ട അടിസ്ഥാന ആവശ്യങ്ങൾക്ക് വളരെ വിലകുറഞ്ഞതാണ്.

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

ഒരു VP- കൾ വാടകയ്ക്കെടുത്ത്, നിങ്ങൾക്ക് പോകാൻ കഴിയുന്ന ധാരാളം സ്ഥലങ്ങളുണ്ട്. Google ക്ലൗഡിന് VPS, KAMTARA, AMAMEN ANMS, കൂടുതൽ ദാതാക്കൾ എന്നിവയും കൂടുതൽ ദാതാക്കളും ഞങ്ങളുടെ ആവശ്യങ്ങൾക്ക് അനുയോജ്യമാകുന്ന ക്ലൗഡ് സെർവർ പരിഹാരങ്ങൾ വാഗ്ദാനം ചെയ്യുന്നു.

നിങ്ങൾ അവരുടെ ഫോമുകളിലൂടെ ക്ലിക്കുചെയ്ത് ആരംഭിക്കാനുള്ള ഒരു പ്ലാൻ തിരഞ്ഞെടുക്കുക. നിങ്ങൾക്ക് ഏതെങ്കിലും ദാതാവിനൊപ്പം ഒരു അടിസ്ഥാന പദ്ധതിയുമായി പോകാം, പക്ഷേ ഇമെയിൽ അയയ്ക്കാൻ പോർട്ട് മെയിൽ സെർവർ പോർട്ടുകൾ തുറക്കാൻ ദാതാവ് നിങ്ങളെ അനുവദിക്കുന്നുവെന്ന് ഉറപ്പാക്കുക (ഇത് പോർട്ട് 587, പോർട്ട് 25 എന്നിവ ആയിരിക്കണം. ഇതുവരെ എനിക്ക് അയോണോസും കതേതറുമായി ഏറ്റവും മികച്ച അനുഭവം ഉണ്ട്, അവ രണ്ടും പരിധിയില്ലാത്ത ഇമെയിൽ അയയ്ക്കാൻ എന്നെ അനുവദിക്കും, അവരുടെ വിലനിർണ്ണയം വളരെ വിലകുറഞ്ഞതാണ്.

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

ssh-keygen

ഫയൽ സംരക്ഷിച്ച് നിങ്ങൾക്ക് ആവശ്യമെങ്കിൽ അത് പുനരാലേഖനം ചെയ്യുക, നിങ്ങൾ ഇതിനകം ഇല്ലെങ്കിൽ നിങ്ങളുടെ SSH കീകൾ തിരിക്കുക എന്നതാണ് നല്ലത്. ഇപ്പോൾ, നിങ്ങളുടെ SSH കീ കാണുന്നതിന് ഇനിപ്പറയുന്ന കമാൻഡ് ഉപയോഗിക്കാം. നിങ്ങളുടെ വിദൂര സെർവറിലേക്ക് ഇത് പകർത്താൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു, അതിനാൽ പ്രാമാണീകരിക്കാൻ നിങ്ങൾക്ക് ഇത് ഉപയോഗിക്കാം.

cat ~/.ssh/id_rsa.pub

ആ കമാൻഡ് ടൈപ്പുചെയ്യുമ്പോൾ നിങ്ങൾക്ക് ഒരു ssh കീ കാണാൻ കഴിഞ്ഞില്ലെങ്കിൽ ("SSH-RSA AAA" ഉപയോഗിച്ച് ആരംഭിക്കുന്ന അക്കങ്ങളുടെയും അക്ഷരങ്ങളുടെയും ഒരു നീണ്ട സ്ട്രിംഗ്), ഒരു ആർഎസ്എ കീ സൃഷ്ടിക്കാൻ ശ്രമിക്കുക (അവ കൂടുതൽ സുരക്ഷിതമാണ്, അതിനാൽ ഞാൻ അവ ഉപയോഗിക്കാൻ ഉപദേശിക്കുന്നു.) അതിനാൽ ഞാൻ അവ ഉപയോഗിക്കാൻ നിർദ്ദേശിക്കുന്നു.

ssh-keygen -t rsa -b 4096

ഉബുണ്ടു പ്രവർത്തിക്കുന്ന ഒരു വിപിഎസ് സൃഷ്ടിക്കുക, എന്നിരുന്നാലും നിങ്ങൾ ഇത് ചെയ്യാൻ പദ്ധതിയിടുന്നു. ദാതാക്കളുടെ വെബ്സൈറ്റിലെ ഫോമുകളിൽ ക്ലിക്കുചെയ്ത് നിങ്ങൾ ഒരു VP- കൾ സൃഷ്ടിച്ചുകഴിഞ്ഞാൽ, നിങ്ങൾ ലോഗിൻ ചെയ്യാൻ ആഗ്രഹിക്കുന്നു. ഇത് ചെയ്യുന്നതിന്, നിങ്ങളുടെ ഐപി വിലാസം ഉപയോഗിച്ച് SSH കമാൻഡ് ഉപയോഗിക്കുക (xx.xx.xx.xx പോലെ ssh കമാൻഡ് ഉപയോഗിക്കുക). ഞങ്ങൾ സൃഷ്ടിച്ച സെർവറിലെ സ്ഥിരസ്ഥിതി ഉപയോക്തൃനാമത്തിലേക്ക് നിങ്ങൾ സെൻസിറ്റീവ് ആയിരിക്കണം, ഉദാഹരണത്തിന്, ഉബുണ്ടു.

ssh ubuntu@XX.XX.XX.XX

നിങ്ങൾക്ക് പാസ്വേഡ് ആവശ്യപ്പെട്ടാൽ നിങ്ങൾക്ക് പാസ്വേഡ് ആവശ്യപ്പെടാം, അതിൽ പ്രവേശിക്കുക. ഞങ്ങൾ സ്ഥിരസ്ഥിതി ഉപയോക്തൃനാമം ഉപയോഗിക്കില്ല, അതിനാൽ ഒരു പുതിയ ഉപയോക്താവ് സൃഷ്ടിച്ച് അവരുടെ അക്കൗണ്ടിലേക്ക് ഒരു ssh കീ ചേർത്ത് നമുക്ക് ആരംഭിക്കാം.

ഒരു പുതിയ sshd_config ഫയൽ ചേർത്ത് നമുക്ക് SSH എങ്ങനെ ഉപയോഗിക്കാമെന്ന് പറയുന്നു.

nano sshd_config

# ഇതാണ് SSHD സെർവർ സിസ്റ്റം-വൈഡ് കോൺഫിഗറേഷൻ ഫയൽ.  കാണുക
# കൂടുതൽ വിവരങ്ങൾക്ക് sshd_config (5).
# PHATH = / USR / Local / sbin: / usr / sbin: / usr / sbin: / usr / sbr: / sbin: / bin: / usr: / usr / ഗെയിമുകൾ
# ഷിപ്പുചെയ്ത സ്ഥിരസ്ഥിതി sshd_config- ലെ ഓപ്ഷനുകൾക്കായി ഉപയോഗിക്കുന്ന തന്ത്രം
# അവരുടെ സ്ഥിരസ്ഥിതി മൂല്യമുള്ള ഓപ്ഷനുകൾ വ്യക്തമാക്കുക എന്നതാണ് ഓപ്പൺഎസ്എച്ച്എസ്എച്ച്
# സാധ്യമായത്, പക്ഷേ അവരെ അഭിപ്രായമിട്ടു.  അനുവദനീയമായ ഓപ്ഷനുകൾ അസാധുവാക്കുന്നു
# സ്ഥിര മൂല്യം.
# പോർട്ട് 22
# അഭിസംബതമായി ഏതെങ്കിലും
# 0.0.0.0 കേൾക്കുക
# ശ്രീകരിച്ചുള്ളത് ::
# ഹോസ്റ്റ്കീ / etc / ssh / ssh_host_host_rsa_ke
# ഹോസ്റ്റ്കീ / etc / ssh_host_ectsa_ke
# ഹോസ്റ്റ്കീ / etc / ssh / ssh_host_ed25519_കീ
# സിഫറുകളും കീയിംഗും
# റെമിലിമിറ്റ് സ്ഥിരസ്ഥിതി ഒന്നുമില്ല
# പവേശിക്കുക
# സിസ്ലോഗ്ഫാസിറ്റി മൂക്ക്
# ലോഗ്ലെവൽ വിവരം
# പ്രാമാണീകരണം:
# ലോഗ്രേസി ടൈം 2 മി
# പെർമോർറൂട്ട്ലോഗിൻ നിരോധിപ്പിക്കുക-പാസ്വേഡ്
# സ്ട്രോക്റ്റോഡുകൾ അതെ
# മാക്സ്അതർസ് 6
# മാക്സഷൻസ് 10
# ഭാവിയിൽ സ്ഥിരസ്ഥിതിയായി അവഗണിക്കപ്പെടാൻ .എസ്എച്ച് / അംഗീകൃത_കീസ് 2 പ്രതീക്ഷിക്കുക.
# അംഗീകൃതവർഗ്ഗങ്ങൾ ഫയൽ ഒന്നുമില്ല
# രചയിതാവിന്റെ അടുഷണക്കാരൻ ഒന്നുമില്ല
# രചയിതാക്കളുടെ ആരുമായും
# ഇതിനായി നിങ്ങൾക്ക് / etc / ssh / ssh_sshershers_hores- ൽ ഹോസ്റ്റ് കീകൾ ആവശ്യമാണ്
# ഹോസ്റ്റബസെഡൻകെന്റേഷൻ നമ്പർ
# നിങ്ങൾ ~ / .ssh / അറിഞ്ഞ_ഹേൺസ് വിശ്വസിക്കുന്നില്ലെങ്കിൽ അതെ
# ഹോസ്റ്റ്ബസെഡലെക്തി
# അവഗണിക്കുന്നവേഷികർ ഇല്ല
# ഉപയോക്താവിന്റെ ~ / .rhosts, ~ / .shores ഫയലുകൾ വായിക്കരുത്
# അവഗണിക്കുന്നവളെ അതെ
# ടണൽഡ് ടെക്സ്റ്റ് പാസ്വേഡുകൾ അപ്രാപ്തമാക്കുന്നതിന്, ഇവിടെ മാറ്റരുത്!
# പെർമിറ്റ് ഡിസ്റ്റിപാസ്വേഡുകൾ ഇല്ല
# വെല്ലുവിളി-പ്രതികരണ പാസ്വേഡുകൾ പ്രവർത്തനക്ഷമമാക്കുന്നതിന് അതെ എന്നതിലേക്ക് മാറ്റുക (പ്രശ്നങ്ങളുമായി പൊരുത്തപ്പെടുക
# ചില പാം മൊഡ്യൂളുകളും ത്രെഡുകളും)
# കെർബറോസ് ഓപ്ഷനുകൾ
# കെർബേറോസൗട്ടെലിക്കേഷൻ നമ്പർ
# Kerbersorlocalasswd അതെ
# Kerberosticketcleanep അതെ
# കെർബറോസ്ജെറ്റ്സ്സ്റ്റോക്കർ നമ്പർ
# GSSAPI ഓപ്ഷനുകൾ
# Gssapautentication നമ്പർ
# Gssapicleanuccredends അതെ
# Gssapistricctactorcheck അതെ
# Gssapapikeyexchange NO
# പാം പ്രാമാണീകരണം, അക്കൗണ്ട് പ്രോസസ്സിംഗ് എന്നിവ പ്രാപ്തമാക്കുന്നതിന് ഇത് 'അതെ' എന്ന് സജ്ജമാക്കുക,
# സെഷൻ പ്രോസസ്സിംഗ്. ഇത് പ്രാപ്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, പാം പ്രാമാണീകരണം ചെയ്യും
# Kbdinginactiveventication വഴി അനുവദിക്കുക
# പാസ്വേഡ് ഒഴിവാക്കൽ.  നിങ്ങളുടെ പാം കോൺഫിഗറേഷനെ ആശ്രയിച്ച്,
# Kbdingeractitiveentication വഴി pam പ്രാമാണീകരണം ബൈപാസ് ചെയ്യാം
# "പാസ്വേഡ് ഇല്ലാത്ത ബോർട്റൂട്ട്ലോജിൻ" ക്രമീകരണം.
# നിങ്ങൾക്ക് പാം അക്കൗണ്ടും സെഷൻ പരിശോധനയും വേണമെങ്കിൽ
# പാം പ്രാമാണീകരണം, തുടർന്ന് ഇത് പ്രാപ്തമാക്കുക, പക്ഷേ പാസ്വേഡ് ലഭ്യമാക്കൽ സജ്ജമാക്കുക
# ഒപ്പം kbdinginactivewavention 'ഇല്ല'.
# Alowaterswarde അതെ
# AllowtCPWARDES അതെ
# ഗേറ്റ്വൈവോർട്ടുകൾ ഇല്ല
# X11displayoffet 10
# X11uselocalhost അതെ
# പെർമിറ്റി അതെ
# Printlastlog അതെ
# Tcpkeepalive അതെ
# പെരുറൂസറൻവിട്രോൺ നമ്പർ ഇല്ല
# കംപ്രഷൻ വൈകി
# ക്ലയല്ലാവികാരമായവൽ 0
# ClackAlivecountMAX 3
# ഉപയോഗിക്കാത്ത ഇല്ല
# Pidfile / run/sshd.pid
# മാക്സ്സ്റ്റാർട്ടപ്പുകൾ 10: 30: 100
# Pervittunelne ഇല്ല
# Chrootdiractory ഒന്നുമില്ല
# പതിപ്പ്അഡ്ഡം ഒന്നുമില്ല
# സ്ഥിരസ്ഥിതി ബാനർ പാതയില്ല
# ലോക്കേൽ എൻവയോൺമെന്റ് വേരിയബിളുകൾ കൈമാറാൻ ക്ലയന്റിനെ അനുവദിക്കുക
# സബ്സിസ്റ്റമുകളുടെ സ്ഥിരസ്ഥിതി അസാധുവാക്കുക
# ഒരു ഉപയോക്തൃ അടിസ്ഥാനത്തിൽ ക്രമീകരണങ്ങൾ അസാധുവാക്കുന്നതിന്റെ ഉദാഹരണം
# ഉപയോക്തൃ അനോൺസിവികളെ പൊരുത്തപ്പെടുത്തുക
# X11feraind ഇല്ല
# അനുവദിക്കുക
# പെർമിറ്റി നമ്പർ
# Forcecommand cvs സെർവർ

ഫയൽ സംരക്ഷിക്കാൻ Ctrl + X ഉം Y ഉം ഓർമ്മിക്കുക. അടുത്തതായി, നമുക്ക് ഒരു അടിസ്ഥാന സ്ക്രിപ്റ്റ് എന്ന് എഴുതാം (ഞങ്ങളുടെ ഉപയോക്താവിന്റെ സ്ഥിരസ്ഥിതി ഹോം ഡയറക്ടറിയിൽ).

nano initialize

ഈ ലൈനുകൾ ഫയലിലേക്ക് ചേർക്കുക, പകരം വയ്ക്കുകപൂച്ച ഉപയോഗിച്ചിരിക്കുന്ന നിങ്ങളുടെ SSH കീ ഉപയോഗിച്ച്. (.SSH / Id_RSA.PUB)

# ! / ബിൻ / ബാഷ്

ഈ ഫയലിലൂടെ നിങ്ങളെ നടക്കാൻ, ലൈൻ പ്രകാരം വരണ്ടതാക്കാം. ഇത് ഒരു ബാഷ് ലിപിയാണെന്ന് ആദ്യ വരി കംപൈലറുടെ പറയുന്നു. തുടർന്ന് ഞങ്ങൾ SSHD_CONFIG ശരിയായ ഡയറക്ടറിയിലേക്ക് ഇൻസ്റ്റാൾ ചെയ്യുന്നു, SSHD_CONFIG എന്നത് ശരിയായ ഡയറക്ടറിയിലേക്ക് പകർത്തുന്നു, ssh കീകൾ പകർത്തുന്നു, 'ടീം' ചേർക്കുന്നു (നിങ്ങൾക്ക് ഇത്തരത്തിലുള്ള ഒരു പേര് എടുക്കാം, ഇപ്പോൾ അവരുടെ പേരിനൊപ്പം അവരുടെ പേരും അപ്രാപ്തമാക്കിയ പാസ്വേഡും ചേർക്കാം). ഞങ്ങൾ സൂഡോ ഗ്രൂപ്പിലേക്ക് ടീമും ചേർത്ത് അവരുടെ SSH കീ സൃഷ്ടിക്കുക, അംഗീകൃത കീകളിലേക്കും അവയിലേക്കും അവരുടെ കീ ചേർത്ത് അവയുടെ കീ അച്ചടിക്കുക. ഈ പുതിയ ഉപയോക്താവ് ഞങ്ങൾ സൈറ്റിൽ ലോഗിൻ എങ്ങനെ ലോഗിൻ ചെയ്യണം എന്നതാണ്.

ഒരു പുതിയ ടെർമിനലിൽ, മുന്നോട്ട് പോയി സെർവർ വീണ്ടും തുറക്കുക.

ssh team@XX.XX.XX.XX

നിങ്ങൾക്ക് ഒരു പാസ്വേഡ് ആവശ്യമില്ല, നിങ്ങൾക്ക് ഒരു ssh പ്രധാനമാണ്. സൈറ്റ് കൂടുതൽ സുരക്ഷിതമായി സൂക്ഷിക്കുന്നതിന് ഞങ്ങൾ പാസ്വേഡ് ഉപയോഗിച്ച് ലോഗിൻ അപ്രാപ്തമാക്കിയിട്ടുണ്ട്.

ഇപ്പോൾ, ഈ സെർവർ അതിനെക്കുറിച്ചുള്ള ഒരു വിവരവുമില്ലാതെ പൂർണ്ണമായും ശൂന്യമായി ആരംഭിക്കുന്നു. ജിറ്റിൽ നിന്ന് ഞങ്ങളുടെ പ്രോജക്റ്റ് ക്ലോൺ ചെയ്ത് ആരംഭിക്കാം, അതിനാൽ വിദൂര മെഷീനിൽ ഡ download ൺലോഡ് ചെയ്ത് പ്രവർത്തിപ്പിക്കാൻ ഞങ്ങൾക്ക് കഴിയും. SSH- ൽ കണക്റ്റുചെയ്തിരിക്കുന്ന വിദൂര സെർവറിൽ, ആദ്യം നിങ്ങളുടെ SSH കീ അച്ചടിക്കുക:

cat ~/.ssh/id_rsa.pub

അടുത്തതായി, ഞങ്ങളുടെ ജിറ്റ് ശേഖരം സജ്ജീകരിക്കുന്നതിന് മുമ്പ് ഞങ്ങൾ ചെയ്തതിനെപ്പോലുള്ള ജിറ്റ് ക്രമീകരണങ്ങളിലേക്ക് ഈ കീ ഒട്ടിക്കുക. ഞങ്ങൾ ഇപ്പോൾ ഞങ്ങളുടെ പ്രോജക്റ്റ് നേരിട്ട് സെർവറിലേക്ക് ക്ലോൺ ചെയ്യാം. നിങ്ങൾ പ്രാദേശികമായി പ്രോജക്റ്റിൽ ബാക്കപ്പ് ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക, അതിനാൽ ഇത് ഡ download ൺലോഡ് ചെയ്യാനുള്ള ജിറ്റ് സെർവറിൽ ഉണ്ട്.

git clone git://github.com/you/yourproject.git

തികഞ്ഞത്. ഇപ്പോൾ എല്ലാ ഫയലുകളും ഇവിടെയുണ്ട്. നമുക്ക് അവരെ ls ഉപയോഗിച്ച് കാണാം

ls

ഇപ്പോൾ, നമുക്ക് സെർവർ സജ്ജമാക്കാൻ തുടങ്ങാം. ആദ്യം, പ്രോജക്റ്റിനായി ഞങ്ങൾ ഉപയോഗിക്കുന്ന ലളിതവും അവിസ്മരണീയവുമായ പേരിലേക്ക് നിങ്ങളുടെ പ്രോജക്റ്റ് ഡയറക്ടറി പകർത്തുക.

cp -r yourproject whatyoucalledit

നിങ്ങളുടെ പ്രോജക്റ്റിന്റെ പുതിയ പേരാണ് "thatyoucallit". അടുത്തതായി, സെർവർ സജ്ജീകരിക്കുന്നതിന് ഞങ്ങൾ ഒരു അടിസ്ഥാന യൂട്ടിലിറ്റി നിർമ്മിക്കേണ്ടതുണ്ട്. ഞങ്ങൾ ഈ യൂട്ടിലിറ്റി സംരക്ഷിച്ച് ഭാവിയിൽ ഉപയോഗിക്കും. ഈ യൂട്ടിലിറ്റി നിർമ്മിക്കാൻ, ഞങ്ങൾ ഒരു സ്ക്രിപ്റ്റ് എത്തുന്നത് എങ്ങനെയെന്ന് നിർവചിക്കാൻ ഒരു ഉപയോക്താവ് ബൈനറി സൃഷ്ടിക്കാം. ബാഷ് ഉപയോഗിക്കുന്നു, / usr / bin / accript ഉപയോഗിക്കുന്നു

sudo nano /usr/bin/ascript

അവിടെ സുഡോ ഉപയോഗിക്കുന്നത് ഉറപ്പാക്കുക അതിനാൽ ഫയൽ എഡിറ്റുചെയ്യാൻ നിങ്ങൾക്ക് അനുമതികളുണ്ട്. ഫയലിൽ, ഈ വരികൾ ചേർക്കുക:

# ! / ബിൻ / ബാഷ്
    echo "# ! / ബിൻ / ബാഷ് ">> / usr / bin / $ 1

ഈ സ്ക്രിപ്റ്റ് ഒരു വാദം, സ്ക്രിപ്റ്റ് നാമം $ 1 ആയി എടുക്കുന്നുവെന്ന് ഓർമ്മിക്കുക. ഫയൽ നിലവിലുണ്ടോ, അല്ലെങ്കിൽ അത് സൃഷ്ടിക്കുന്നതിനായി, അല്ലെങ്കിൽ അത് സൃഷ്ടിക്കാനുള്ള ആദ്യ വരി ചേർക്കുന്നു, അല്ലെങ്കിൽ അത് ഒരു സ്ക്രിപ്റ്റുകളുടെ പേരുകൾ സംഭരിക്കുന്നതിന് അതിന്റെ പേര് / etc / accripts ചേർക്കുന്നു. ഫയൽ ഇതിനകം നിലവിലുണ്ടെങ്കിൽ, അനുമതികൾ മാറ്റുക, അത് എഡിറ്റുചെയ്യുക. ഫയൽ സംരക്ഷിക്കുക, അടുത്തതായി ഞങ്ങൾ അത് അനുമതികൾ മാറ്റും. ഈ സ്ക്രിപ്റ്റ് ഉപയോഗിക്കുന്നിടത്തോളം കാലം ഞങ്ങൾ അത് വീണ്ടും ചെയ്യേണ്ടതില്ല.

sudo chmod a+x /usr/bin/ascript

തികഞ്ഞത്. ഇപ്പോൾ നമുക്ക് സജ്ജീകരണം എന്ന ഒരു സ്ക്രിപ്റ്റ് സൃഷ്ടിക്കാം. ആദ്യം, നിങ്ങളെ കീഴടക്കുകയല്ല, പക്ഷേ എന്റെ സജ്ജീകരണ സ്ക്രിപ്റ്റ് എന്താണെന്ന് നോക്കുക. നിങ്ങളുടെ പ്രോജക്റ്റിൽ ഈ സ്ക്രിപ്റ്റ് എങ്ങനെയായിരിക്കേണ്ട കാര്യങ്ങളിലൂടെ ഞങ്ങൾ നടക്കും, എന്റെ സ്ക്രിപ്റ്റിൽ നിങ്ങൾക്ക് എല്ലാം ആവശ്യമില്ല.

# ! / ബിൻ / ബാഷ്
# sudo chmod a + x സ്ക്രിപ്റ്റുകൾ / ഉപയോക്താക്കൾ
# ./സ്ക്രിപ്റ്റ്സ്/useretup
# SSH-കീജെൻ
# പ്രോജക്ട് ഡയറക്ടറി
# ലോഗ് കമാൻഡുകൾ
# നാനോ കോൺഫിഗറേഷൻ
# ജിറ്റ് കോൺഫിഗറേഷൻ
# അപ്ഡേറ്റ് ചെയ്ത് ഇൻസ്റ്റാൾ ചെയ്യുക
# ക്ലാമ ആന്റിവൈറസിനെ പ്രാപ്തമാക്കുക
# ഹോസ്റ്റ്നാമം സജ്ജമാക്കുക
# പോസ്റ്റ്ഗ്രെസ് സജ്ജമാക്കുക
# ഡാറ്റാബേസ് ബാക്കപ്പ് സജ്ജമാക്കുക
# ഇപ്റ്റബിൾസ് അപ്രാപ്തമാക്കുക
# ബിറ്റ്ഡെഫെൻഡർ ഇൻസ്റ്റാൾ ചെയ്യുക
# പോസ്റ്റ്ഫിക്സ് സജ്ജമാക്കുക
# മോഷണം സൃഷ്ടിക്കുക
# Virtualenv സജ്ജമാക്കുക
# ഡിപൻഡൻസികൾ നേടുക
# ഫയർവാൾ നിയമങ്ങൾ സജ്ജമാക്കുക
# പൈപ്പ് ഡിപൻഡൻസികൾ ഇൻസ്റ്റാൾ ചെയ്യുക
pip3 install --upgrade opencv-python # == 4.5.4.60
pip3 install --upgrade opencv-contrib-python # == 4.5.4.60
# pip ഇൻസ്റ്റാൾ ചെയ്യുക Opencv-python == 4.5.5.64
# pip ഇൻസ്റ്റാൾ ചെയ്യുക ഓപാൻസിവി-സംഭാവന-പൈത്തൺ == 4.5.5.64
# സ്റ്റാർബോട്ട് ഇൻസ്റ്റാൾ ചെയ്യുക
# സർട്ട്ബോട്ട് പ്രവർത്തിപ്പിക്കുക
# മെയിൽ സെർവർ വീണ്ടും ലോഡുചെയ്യുക
# കെട്ടുകൾ പകർത്തുക
# sudo cp /etc/letsencrypt/live/femmebe.com/priveke.pem pviskey.pem
# sudo cp /etc/letsencrypt/live/femebebe.com/cert.peme att.pem
# പാച്ച് വെൻവി
# ഉപയോക്തൃ ക്രമീകരണങ്ങൾ സജ്ജമാക്കുക
# അനുമതികൾ സജ്ജമാക്കുക
# sudo chown -r ടീം: ഉപയോക്താക്കൾ / var / റൺ /
# സുഡോ ചൗൺ റൂട്ട്: റൂട്ട് / റൺ / സുഡോ / ടിഎസ് -r
# sudo chmod 664 db.sqlite3
# sudo chown Www-ഡാറ്റ: ഉപയോക്താക്കൾ Db.sqlite3
# കോൺഫിഗറേഷൻ പകർത്തി അനുമതികൾ സജ്ജമാക്കുക
# സജ്ജീകരണ ഡാറ്റാബേസ് സജ്ജമാക്കുക
# പാം കോൺഫിഗെറ്റ് ചെയ്യുക, തെറ്റായ SSH കോൺഫിഗറി നീക്കംചെയ്യുക
# sudo sed -i '-e' $ d '/etc/pam.d/sSHD
# സുഡോ സെഡി-ഞാൻ '-e' $ d '/ etc / exp
# ബിൻ സ്ക്രിപ്റ്റുകളും അനുമതികളും സജ്ജമാക്കുക
# സേവനങ്ങൾ വീണ്ടും ലോഡുചെയ്യുക, പ്രാപ്തമാക്കുക
# അപ്പാച്ചെ മൊഡ്യൂളുകൾ പ്രവർത്തനക്ഷമമാക്കുക
# sudo a2disod mpm_event
# sudo a2disod mpm_worker
# sudo a2enmod mpm_preake
# സ്ഥിരസ്ഥിതി സൈറ്റ് പ്രവർത്തനരഹിതമാക്കുക
# ഞങ്ങളുടെ സൈറ്റ് പ്രവർത്തനക്ഷമമാക്കുക
# ഡെമൺ വീണ്ടും ലോഡുചെയ്യുക, അപ്പാച്ചെ, പോസ്റ്റ്ഫിക്സ്, ഓപ്പൺകീം
# അനുമതികൾ സജ്ജമാക്കുക
# ക്രമീകരണം സ്വാപ്പ് ചെയ്യുക
# ഇനിറ്റ് അടിക്കുറിപ്പ് എഞ്ചിൻ
# സജ്ജമാക്കുക ജിറ്റ്
# ഡൊമെയ്ൻ കോൺഫിഗറേഷനായി IPv6, Opendkim എന്നിവ കാണിക്കുക
# സജ്ജീകരണം പൂർത്തിയായി

അത് ഒരുപാട് സജ്ജീകരണമാണ്! ചുരുക്കത്തിൽ, ഈ കോഡ് ലോഗുകൾ കമാൻഡുകൾ, ഫയലുകളുടെ പകർപ്പുകൾ ക്രമീകരിക്കുക, ഡ download ൺലോഡ് ചെയ്യുകയും ഇൻസ്റ്റാൾ ചെയ്യുകയും ചെയ്യുന്നു, അത് ഡ download ൺലോഡുകൾ ചെയ്യുകയും ഇൻസ്റ്റാൾ ചെയ്യുകയും ചെയ്യുന്നു, ഒപ്പം ഒരു ആന്റിവൈറസ് ചെയ്യുക, ഡയറക്ടറികൾ, ക്ലോൺസ് ഡിപൻഡൻസ്, സർട്ടിഫിക്കറ്റുകൾ എന്നിവ ക്രമീകരിക്കുക സെർവർ സജ്ജമാക്കുക, കോൺഫിഗറേഷൻ ഇൻസ്റ്റാളുചെയ്യുന്നു, ആരംഭിച്ച് ആരംഭിക്കുകയും ആരംഭിക്കുകയും സ്വാപ്പ് ചെയ്യാം, സ്വാപ്പ് പ്രാപ്തമാക്കുന്നു, അനുമതികൾ സജ്ജമാക്കുകയും ഐപി, ഐപിവി 6 വിലാസവും ഓപ്പൺകീം കീയും പ്രിന്റുചെയ്യുകയും ചെയ്യുന്നു. വളരെ ലളിതമാണ്, പക്ഷേ അത് ധാരാളം കോഡ് പോലെ കാണപ്പെടുന്നു. ഞങ്ങൾക്ക് ഇതിൽ ഒരുപാട് ആവശ്യമില്ല, കാരണം ഞങ്ങൾ ഡിപൻഡൻസികൾ ഇല്ലാത്തതിനാൽ, ഞങ്ങൾ സെലറി, സെലറിബീറ്റ് അല്ലെങ്കിൽ ഡാഫ്നെ ഉപയോഗിക്കുന്നില്ല, പക്ഷേ അവയിൽ ചിലത് ആരംഭിക്കുന്നതിന് ഞങ്ങൾ അവ ഇൻസ്റ്റാൾ ചെയ്യും. ഈ കോഡിന് നിരവധി തവണ ഒരു ഡൊമെയ്ൻ പ്രഖ്യാപിച്ചിട്ടുണ്ടെന്ന് ശ്രദ്ധിക്കുക.

ഞങ്ങൾ ഒരു ഡൊമെയ്ൻ നാമം വാങ്ങേണ്ടതുണ്ട് (അത് ഒരു ചെറിയ വാർഷിക ഫീസാണ്). ഒരു ഡൊമെയ്ൻ വാങ്ങുന്നതിന് സ്ക്വയർസ്പേസ് ഞാൻ ശുപാർശ ചെയ്യുന്നു, അവയുടെ ലേ layout ട്ട് അവബോധജന്യവും ഉപയോഗിക്കാൻ എളുപ്പവുമാണ്. നിങ്ങൾക്ക് ഇഷ്ടമുള്ള ഏത് ഡൊമെയ്നും വാങ്ങാം, പക്ഷേ ഞാൻ ഈ ഉദാഹരണത്തിൽ ഡൊമെയ്ൻ ഫെംബാബെ.കോം ഉപയോഗിക്കുന്നു. നിങ്ങൾ ഒരു ഡൊമെയ്ൻ വാങ്ങിയുകഴിഞ്ഞാൽ, സ്ക്വയർസ് ഡെൻസ് കോൺഫിഗറേഷൻ പാനലിലേക്ക് പോയി ഐപി വിലാസം സെർവറിലേക്ക് നിങ്ങളുടെ ഡൊമെയ്ൻ ചൂണ്ടിക്കാണിക്കുന്ന ഒരു റെക്കോർഡ് ചേർക്കുക. ഇത് ഇങ്ങനെയായിരിക്കണം:

@ ഒരു xx.xx.xxx

@ ഓപ്പറേറ്റർ ഹോസ്റ്റിലായതിനാൽ, ഈ ഡൊമെയ്നിന് കീഴിലുള്ള എല്ലാ ഉപഡൈനുകളും എല്ലാം സെർവറിലേക്ക് റീഡയറക്ട് ചെയ്യും. പ്രഖ്യാപിക്കാൻ കൂടുതൽ റെക്കോർഡുകൾ ഉണ്ട്, പക്ഷേ ഞങ്ങൾക്ക് മെയിൽ അയയ്ക്കാൻ തയ്യാറായിക്കഴിഞ്ഞാൽ നമുക്ക് ഇവയിലേക്ക് പോകാം. ഓർമ്മിക്കുക, ഇത് സെർവറിൽ നിന്ന് മെയിൽ വിജയകരമായി അയയ്ക്കുന്നതിന് കുറച്ച് ദിവസമെടുക്കും. നമ്മൾ സജ്ജീകരിക്കുന്ന DNS റെക്കോർഡുകൾ പ്രചരിപ്പിക്കാൻ സമയമെടുക്കും.

എന്തായാലും, ഞങ്ങൾ ആരംഭിക്കേണ്ട ഒരേയൊരു റെക്കോർഡ് ഒരു റെക്കോർഡാണ്. അതിനാൽ ഇപ്പോൾ ഞങ്ങളുടെ പ്രോജക്റ്റ് അനുസരിച്ച് നമുക്ക് ചുവടെയുള്ള സ്ക്രിപ്റ്റ് പൂരിപ്പിക്കാൻ കഴിയും.

ഒരു അടിസ്ഥാന പുരോഗതിക്കായി നമുക്ക് ആവശ്യമുള്ളത് ഇൻസ്റ്റാൾ ചെയ്യുന്നതിന് ഒരു ചെറിയ സജ്ജീകരണ സ്ക്രിപ്റ്റ് ഉപയോഗിച്ച് ആരംഭിക്കാം. ഇതുവരെ നിരവധി ഡിപൻഡൻസി അല്ലെങ്കിൽ postgresql ഉപയോഗിക്കില്ല, ഞങ്ങൾ ഒരു അടിസ്ഥാന എച്ച്ടിടിപി സെർവർ ആരംഭിച്ച് അത് പൂർത്തിയാകുമ്പോൾ അത് സാക്ഷ്യം വഹിക്കുന്നതിനെക്കുറിച്ച് വിഷമിക്കും. ഒരു എച്ച്ടിടിപിഎസ് സർട്ടിഫിക്കറ്റ് നേടുകയും സെർവർ സുരക്ഷിതമായി പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുക, ഞങ്ങൾ ഒരു സെർവർ വാടകയ്ക്കലിനൊപ്പം ഒരു ഡൊമെയ്ൻ വാങ്ങേണ്ടതുണ്ട്. ഇപ്പോൾ, നിങ്ങളുടെ ഉപയോക്താവിന്റെ പേര്, നിങ്ങളുടെ പ്രോജക്ട് ഡയറക്ടറി ഉപയോഗിച്ച് "ഡിയർ" എന്ന പേരിൽ "ടീം" മാറ്റിസ്ഥാപിക്കുക, കൂടാതെ നിങ്ങളുടെ ഇമെയിൽ, ഡൊമെയ്ൻ എന്നിവ <> ടാഗുകളിൽ വിതരണം ചെയ്യുക.

കൂടാതെ, ഞങ്ങൾ ഈ കോഡ് പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ്, ഫയർവാളിലേക്കുള്ള ക്രമീകരണങ്ങൾ ഞങ്ങൾ മാറ്റേണ്ടതുണ്ട്, ഹോസ്റ്റിംഗ് ദാതാവ്, ആരെങ്കിലും ഉണ്ടെങ്കിൽ. സാധാരണയായി ഇത് നിങ്ങളുടെ ഹോസ്റ്റിംഗ് ദാതാവിന്റെ 'നെറ്റ്വർക്കിന്റെ ടാബിലാണ്, അല്ലെങ്കിൽ നിങ്ങൾ സ്വയം ഹോസ്റ്റിംഗ് ആണെങ്കിൽ, നിങ്ങളുടെ റൂട്ടറിന്റെ' പോർട്ട് ഫോർവേഡിംഗ് 'വിഭാഗത്തിൽ നിങ്ങൾ സ്വയം ഹോസ്റ്റിംഗ് ആണെങ്കിൽ. നിങ്ങൾ സ്വയം ഹോസ്റ്റിംഗ് ഉപയോഗിക്കുകയാണെങ്കിൽ, നിങ്ങളുടെ സെർവർ മെഷീന്റെ വിലാസം ഉപയോഗിച്ച് നിങ്ങളുടെ റൂട്ടറിലൂടെ ഒരു സ്റ്റാറ്റിക് ഐപി സജ്ജമാക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു. വായന / എഴുത്ത് ആക്സസ്സിനായി നിങ്ങൾ ഇനിപ്പറയുന്ന പോർട്ടുകൾ തുറക്കേണ്ടതുണ്ട്.

22 (ssh) 25 (മെയിൽ) 587 (മെയിൽ) 110 (മെയിൽ ക്ലയന്റ്) 80 (http) 443 (https)

# ! / ബിൻ / ബാഷ്
# ലോഗ് കമാൻഡുകൾ
# നാനോ കോൺഫിഗറേഷൻ
# ജിറ്റ് കോൺഫിഗറേഷൻ
# അപ്ഡേറ്റ് ചെയ്ത് ഇൻസ്റ്റാൾ ചെയ്യുക
# ക്ലാമ ആന്റിവൈറസിനെ പ്രാപ്തമാക്കുക
# ഹോസ്റ്റ്നാമം സജ്ജമാക്കുക
# ഡാറ്റാബേസ് ബാക്കപ്പ് സജ്ജമാക്കുക
# ഇപ്റ്റബിൾസ് അപ്രാപ്തമാക്കുക
# Virtualenv സജ്ജമാക്കുക
# സ്റ്റാർബോട്ട് ഇൻസ്റ്റാൾ ചെയ്യുക
# സർട്ട്ബോട്ട് പ്രവർത്തിപ്പിക്കുക
# ഉപയോക്തൃ ക്രമീകരണങ്ങൾ സജ്ജമാക്കുക
# അനുമതികൾ സജ്ജമാക്കുക
# sudo chown -r ടീം: ഉപയോക്താക്കൾ / var / റൺ /
# സുഡോ ചൗൺ റൂട്ട്: റൂട്ട് / റൺ / സുഡോ / ടിഎസ് -r
# സേവനങ്ങൾ വീണ്ടും ലോഡുചെയ്യുക, പ്രാപ്തമാക്കുക
# അപ്പാച്ചെ മൊഡ്യൂളുകൾ പ്രവർത്തനക്ഷമമാക്കുക
# ഡെമൺ വീണ്ടും ലോഡുചെയ്യുക, അപ്പാച്ചെ, പോസ്റ്റ്ഫിക്സ്, ഓപ്പൺകീം
# ഡൊമെയ്ൻ കോൺഫിഗറേഷനായി IPv6, Opendkim എന്നിവ കാണിക്കുക

ഈ കോഡ് പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ്, നിങ്ങൾ വാങ്ങിയ ഡൊമെയ്ൻ സെർവറിലേക്ക് കണക്റ്റുചെയ്യുമെന്ന് ഉറപ്പാക്കുക. ഇത് ചെയ്യുന്നതിന്, നിങ്ങളുടെ പ്രാദേശിക മെഷീനിൽ ഒരു ടെർമിനൽ തുറക്കുക, നിങ്ങളുടെ ഡൊമെയ്നിൽ ഈ കമാൻഡ് പ്രവർത്തിപ്പിക്കുക:

ping femmebabe.com # പിംഗ് ചെയ്ത ശേഷം നിങ്ങളുടെ ഡൊമെയ്ൻ ഇവിടെ തിരുകുക

എല്ലാം ശരിയാണെന്ന് തോന്നുന്നുവെങ്കിൽ, സെർവർ പ്രതികരണങ്ങൾ അയയ്ക്കുന്നുവെങ്കിൽ, ഞങ്ങൾ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുകയും പാക്കേജുകൾ ഇൻസ്റ്റാൾ ചെയ്യാനും ഞങ്ങളുടെ അപ്പാച്ചെ സെർവർ പ്രാപ്തമാക്കാനും പ്രാപ്തമാക്കാനും സാക്ഷ്യപ്പെടുത്താനും ഞങ്ങൾ തയ്യാറാണ്.

പോസ്റ്റ്ഫിക്സ് ക്രമീകരിക്കുന്നതിന് ഇത് ആവശ്യമായ സജ്ജീകരണമല്ല, ഞങ്ങൾ ആ സജ്ജരണം പിന്നീട് നോക്കും. ഇപ്പോൾ, ഈ സജ്ജീകരണ കോഡ് പ്രവർത്തിപ്പിക്കുക, നിങ്ങളുടെ സെർവർ ഇൻസ്റ്റാൾ ചെയ്യാനും സാക്ഷ്യപ്പെടുത്താനും കുറച്ച് മിനിറ്റ് എടുക്കണം. നിങ്ങൾ വാങ്ങിയ പേര് അനുസരിച്ച് നാമം, ഇമെയിൽ, ഡൊമെയ്ൻ നാമം എന്നിവ സ്ക്രിപ്റ്റിൽ മാറ്റിസ്ഥാപിക്കുന്നത് ഉറപ്പാക്കുക.

ഇപ്പോൾ സെർവർ പ്രൊവീക്കൈനനുസരിച്ച്, നിങ്ങൾക്ക് ഏത് വെബ് ബ്ര browser സറിലും URL ലേക്ക് പോയി സെർവർ എച്ച്ടിടിപിഎസ് പ്രവർത്തിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കാൻ നിങ്ങൾക്ക് കഴിയും. അത് ഇല്ലെങ്കിൽ, ഡിഎൻഎസ് റെക്കോർഡുകൾക്ക് കുറച്ച് സമയമായി കാത്തിരിക്കുക, തുടർന്ന് വീണ്ടും സ്ട്രി സെർട്ട്ബോട്ട് സർട്ടിഫിക്കേഷൻ വീണ്ടും ശ്രമിക്കുക:

sudo certbot --apache --non-interactive --agree-tos --domains <domain>.com --email <youremail>@gmail.com

നിങ്ങൾ എല്ലാം ശരിയായി ക്രമീകരിച്ചിരിക്കുന്നിടത്തോളം കാലം, നിങ്ങളുടെ കോഡ് പ്രവർത്തിക്കുന്നുണ്ടെന്നും ഒരു തത്സമയ വെബ്പേജ് പ്രദർശിപ്പിക്കുന്നിടത്തോളം അപ്പാച്ചെയുടെ സ്ഥിരസ്ഥിതി പേജ് ആക്സസ് ചെയ്യാൻ നിങ്ങൾക്ക് കഴിയണം. അടുത്തതായി, ഞങ്ങളുടെ സ്ഥിരസ്ഥിതി ഡീബഗ് മോഡ് ഉൽപാദനത്തിലേക്ക് മാറ്റാൻ ക്രമീകരണം. PPy എഡിറ്റുചെയ്യാം. ക്രമീകരണങ്ങളിലും ആന്തരിക ഐപിഎസിലും ഞങ്ങൾ ഡൊമെയ്ൻ ക്രമീകരിക്കും.

nano yourproject/settings.py

ക്രമീകരണങ്ങളിൽ, ഈ വരികൾ മാറ്റുക / ചേർക്കുക.

# സൈറ്റ് കോൺഫിഗറേഷൻ

ഇപ്പോൾ, ഞങ്ങൾ അപ്പാച്ചെ 2 ക്രമീകരിക്കേണ്ടതുണ്ട്. ഈ വരിയുമായി ഞങ്ങൾ കോൺഫിഗറേഷൻ ഫയൽ എഡിറ്റുചെയ്യാം:

sudo nano /etc/apache2/sites-available/femmebabe-le-ssl.conf

ഈ കോൺഫിഗറേഷൻ ഫയലിന് അതിൽ ഞങ്ങളുടെ ഡൊമെയ്ൻ നാമം ഉണ്ടായിരിക്കണം, കൂടാതെ ഉപയോക്താവിന്റെയും പ്രോജക്റ്റിന്റെയും പേരും. ഞാൻ ഫെംനാം ടീം, ഉപയോക്തൃനാമ ടീം എന്നിവ ഡൊമെയ്ൻ നാമം ഉപയോഗിക്കുന്നു, പ്രോജക്ട് നാമം ഫെംബാബെ.

ServerSignature Off
ServerTokens Prod
<IfModule mod_ssl.c>
<VirtualHost *:80> 
	Redirect permanent / https://femmebabe.com/
</VirtualHost>
<VirtualHost *:443>
	ServerName femmebabe.com
	ServerAdmin team@femmebabe.com
	DocumentRoot /var/www/html

	ErrorLog ${APACHE_LOG_DIR}/error.log
	CustomLog ${APACHE_LOG_DIR}/access.log combined
	
	Alias /static /home/team/femmebabe/static
	<Directory /home/team/femmebabe/static>
		Require all granted
	</Directory>

Alias /media/icons /home/team/femmebabe/media/
<Directory /home/team/femmebabe/media>
Require all granted
</Directory>

	<Directory /home/team/femmebabe/femmebabe>
		<Files wsgi.py>
			Require all granted
		</Files>
	</Directory>

	WSGIScriptAlias / /home/team/femmebabe/femmebabe/wsgi.py
	WSGIDaemonProcess femmebabe python-path=/home/team/femmebabe/ python-home=/home/team/femmebabe/venv header-buffer-size=100000000000 user=team
	WSGIProcessGroup femmebabe
	WSGIApplicationGroup %{GLOBAL}
	
	<Directory /home/team/femmebabe/static>
                Options Indexes FollowSymLinks
                AllowOverride All
	</Directory>

	<IfModule mod_rewrite.c>
		RewriteEngine on
		RewriteCond %{REQUEST_URI} \.(css|webp|webm|gif|png|mp3|wav|jpeg|jpg|svg|webp)$ [NC]
		RewriteCond %{HTTP_REFERER} !^https://femmebabe.com/media/.*$ [NC]
		RewriteRule ^(.+?)/$ /media/$1 [F,L]
	</IfModule>

	Include /etc/letsencrypt/options-ssl-apache.conf
	SSLCertificateFile /etc/letsencrypt/live/femmebabe.com/fullchain.pem
	SSLCertificateKeyFile /etc/letsencrypt/live/femmebabe.com/privkey.pem

	Header set X-Frame-Options: "SAMEORIGIN"
	Header set Access-Control-Allow-Origin "https://femmebabe.com"

	TimeOut 60000
	LimitRequestBody 0

	<FilesMatch ".(ico|pdf|flv|jpg|jpeg|png|gif|webp|JPG|JPEG|wav|mp3|mp4|public|js|css|swf|webp|svg)$">
		Header set Cache-Control "max-age=30, public"
	</FilesMatch>
</VirtualHost>
</IfModule>
<IfModule mod_ssl.c>
<VirtualHost *:80>
	ServerName femmebabe.com
	ServerAdmin team@femmebabe.com
	DocumentRoot /var/www/html

	ErrorLog ${APACHE_LOG_DIR}/error.log
	CustomLog ${APACHE_LOG_DIR}/access.log combined

	RewriteEngine on
	RewriteCond %{SERVER_NAME} =femmebabe.com
	RewriteRule ^ https://%{SERVER_NAME}%{REQUEST_URI} [END,NE,R=permanent]
</VirtualHost>
</IfModule>

നിങ്ങളുടെ സെർവർ ക്രമീകരിക്കുമ്പോൾ പ്രോജക്റ്റ്, ഡയറക്ടറികൾ, ഡൊമെയ്ൻ എന്നിവയുടെ പേര് ഈ ഉദാഹരണ കോഡിൽ മാറ്റിസ്ഥാപിക്കുന്നത് ഉറപ്പാക്കുക. ഇപ്പോൾ, ഞങ്ങൾ സ്ഥിരസ്ഥിതി സൈറ്റ് അപ്രാപ്തമാക്കേണ്ടതുണ്ട്. ബാഷ് ഉപയോഗിച്ച് ഇത് ചെയ്യാൻ കഴിയും.

sudo a2dissite 000-default-le-ssl
sudo a2dissite 000-default
sudo a2dissite default-ssl

അടുത്തതായി, ഞങ്ങൾക്ക് സ്ഥിരസ്ഥിതി സൈറ്റ് പ്രവർത്തനക്ഷമമാക്കാനും ബാഷ് ഉപയോഗിക്കുകയും ചെയ്യും. / Etc / അപ്പാച്ചെ 2 / സൈറ്റുകളിൽ എഡിറ്റുചെയ്യുമ്പോൾ നിങ്ങൾ പ്രഖ്യാപിച്ച ഫയലിന്റെ പേരിനൊപ്പം നിങ്ങൾ പ്രഖ്യാപിച്ച ഫൈൻബാബെനെ മാറ്റിസ്ഥാപിക്കുക / ലഭ്യമാണ്.

sudo a2ensite femmebabe-le-ssl
sudo systemctl reload apache2

നവബാറിൽ നിങ്ങളുടെ ഡൊമെയ്നിലേക്ക് മടങ്ങുക. നിങ്ങളുടെ വെബ് ബ്ര .സറിൽ നിങ്ങൾ ക്രമീകരിച്ച സൈറ്റ് നിങ്ങൾ കാണും. അഭിനന്ദനങ്ങൾ! നിങ്ങൾ അത് കാണുന്നില്ലെങ്കിൽ, നിങ്ങൾ ചില മാറ്റങ്ങൾ വരുത്തേണ്ടതുണ്ട്. നിങ്ങളുടെ പ്രോജക്റ്റ്, അപ്പാച്ചെ കോൺഫിഗറേഷൻ എന്നിവയിലെ ക്രമീകരണങ്ങൾ ശ്രദ്ധാപൂർവ്വം അവലോകനം ചെയ്യുക, നിങ്ങൾക്ക് പിശകുകൾ ഇല്ലെന്ന് ഉറപ്പാക്കുക, കൂടാതെ പിശകുകൾക്കായി പ്രോജക്റ്റ് പരിശോധിക്കുന്നതിന് ഇനിപ്പറയുന്ന കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുക.

cd projectname
source venv/bin/activate
python manage.py check

നിങ്ങളുടെ പൈത്തൺ പ്രോജക്റ്റിൽ നിങ്ങൾക്ക് പിശകുകൾ ഉണ്ടെങ്കിൽ, അവർ എവിടെയായിരുന്നാലും അവ പരിഹരിക്കുക. നിങ്ങളുടെ എല്ലാ പിശകുകളും അവർ എവിടെയായിരുന്നാലും കാണാൻ കഴിഞ്ഞേക്കില്ല, അതിനാൽ "ജനസംഖ്യ യാന്ത്രാമമല്ല" എന്ന് നിങ്ങൾക്ക് ഒരു പിശക് ഉണ്ടെങ്കിൽ, പിശക് തുറന്നുകാട്ടുന്നതിന് വെർച്വൽ എൻവയോൺമെന്റ്, രജിസ്ട്രി.പി.വൈ എഡിറ്റുചെയ്യുക.

nano venv/lib/python3.12/site-packages/django/apps/registry.py

ഈ റൺടൈം പിശക് ("റൺമെന്റായി" ഉയർത്തിക്കാണുന്നത് (റുലിം പിശക് "), (verunimeare () ഉയർത്തുക"), ഈ വരിയ്ക്ക് മുമ്പായി ഒരു അഭിപ്രായം ചേർക്കുക, തുടർന്ന്, sel.app_configs =}. ഇത് ഇതുപോലെ തോന്നുന്നു:

                # Appconfigg.redi () പ്രവർത്തിപ്പിക്കുന്നത് ഒഴിവാക്കാൻ വീണ്ടും പ്രവേശിക്കുന്നത് തടയുക
                # രണ്ടുതവണ രീതികൾ.
# RuntorimeError ("ജനസംഖ്യ () വീണ്ടും പ്രവേശിച്ചിട്ടില്ല")

നിങ്ങൾക്ക് അത് വീണ്ടും പ്രോജക്റ്റ് പരിശോധിച്ച് പിശക് തുറന്നുകാട്ടുന്നു.

python manage.py check

അപ്പോൾ നിങ്ങൾക്ക് പിശക് കാണാനും പരിഹരിക്കാനും കഴിയും. നിങ്ങൾ അത് ശരിയാകുമ്പോഴും കോഡ് പിശകുകളില്ലാതെ കംപൈൽ ചെയ്യുന്നു, ഫയൽ തിരികെ മാറ്റുന്നത് ഉറപ്പാക്കുക, അതിനാൽ ഇത് ഇങ്ങനെ കാണപ്പെടുന്നു:

                # Appconfigg.redi () പ്രവർത്തിപ്പിക്കുന്നത് ഒഴിവാക്കാൻ വീണ്ടും പ്രവേശിക്കുന്നത് തടയുക
                # രണ്ടുതവണ രീതികൾ.
# self.app_confics = {}

സെർവർ ഓൺലൈനിലാണെന്ന് നൽകിയിട്ടുണ്ടെങ്കിൽ, ഞങ്ങൾ ഇതിലേക്ക് കൂടുതൽ മാറ്റങ്ങൾ വരുത്തുമ്പോൾ, സെർവർ വീണ്ടും ലോഡുചെയ്യാൻ ഇനിപ്പറയുന്ന കമാൻഡ് ഉപയോഗിക്കേണ്ടതുണ്ട്:

sudo systemctl reload apache2

ആകർഷണീയമായത്! എന്നാൽ മെയിൽ അയയ്ക്കുന്നതിനെക്കുറിച്ച്? ഇമെയിൽ അയയ്ക്കാൻ ആരംഭിക്കുന്നതിന്, ഞങ്ങൾ ആദ്യം ഡൊമെയ്ൻ കോൺഫിഗറേഷൻ അപ്ഡേറ്റ് ചെയ്യേണ്ടതുണ്ട്. ഇത് നിങ്ങളുടെ ഡിഎൻഎസ് പാനലിലായിരിക്കണം, അല്ലെങ്കിൽ നിങ്ങൾ തിരഞ്ഞെടുത്ത ഡൊമെയ്ൻ നെയിം രജിസ്ട്രാറായിരിക്കണം. കോൺഫിഗറേഷൻ ഇൻസ്റ്റാൾ ചെയ്ത് ചേർത്ത് കുറച്ച് കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കാനും ഞങ്ങൾ ആവശ്യമാണ്.

ആദ്യം, നമുക്ക് സെർവറിന്റെ IPv6 വിലാസം നേടാം. ഞങ്ങൾ നിങ്ങളുടെ DNS തുറന്ന് റെക്കോർഡുകൾ ചേർക്കും.

സെർവറിന്റെ IPv6 വിലാസം ലഭിക്കുന്നതിന്, ഈ കമാൻഡ് ഉപയോഗിക്കുക:

ip -6 addr

ഇപ്പോൾ, ഡിഎൻഎസ് ക്രമീകരണങ്ങളിലേക്ക് ഇനിപ്പറയുന്ന റെക്കോർഡുകൾ ചേർക്കാൻ കഴിയും. എന്റെ റെക്കോർഡുകൾ ഇതുപോലെ തോന്നുന്നു. എന്നിരുന്നാലും, നിങ്ങളുടെ റെക്കോർഡുകൾക്കായി, നിങ്ങൾ ഐപി വിലാസം നിങ്ങളുടെ ഐപിയുമായി മാറ്റിസ്ഥാപിക്കണം (75.147.182.214 അല്ല, അതാണ് എന്റെ. നിങ്ങളുടെ ഡൊമെയ്നിനും, അതുപോലെ തന്നെ നിങ്ങളുടെ ഡൊമെയ്ൻ ചേർക്കുക, നിങ്ങളുടെ IPv6 വിലാസവും മുമ്പത്തെ കമാൻഡ് ഉപയോഗിച്ച് കണ്ടെത്തി (നിങ്ങൾക്ക് എന്റേത് ഉപയോഗിക്കാൻ കഴിയില്ല, Fe0 :: 725 എ: FFF: FE49: 3E02). ഇപ്പോൾ ഡൊമെയ്ൻകീയെക്കുറിച്ച് വിഷമിക്കേണ്ട, ഞങ്ങൾ പോസ്റ്റ്ഫിക്സ്, മെയിൽ സെർവർ സജ്ജമാക്കിയപ്പോൾ ഓപ്പൺകിം ഉപയോഗിച്ച് സജ്ജമാക്കിയപ്പോൾ ഇത് സൃഷ്ടിച്ചു, കീ പ്രിന്റ് ചെയ്യുക. ഞങ്ങൾ അവസാനമായി ഇത് ക്രമീകരിക്കും.

@ ഒരു N / A. 75.147.182.2114

@ മിക്സ് 10 semmebe.com

@ പിടിആർ N / A. semmebe.com

@ ടെക്സ്റ്റ് N / A. Txt @ v = spf1 mx ip75.147.182.214ip6: Fe0 :: 725 എ: FFF: FE49: 3E02 ~ എല്ലാം

സ്ഥിരസ്ഥിതി ._ബിമി ടെക്സ്റ്റ് N / A. v = bimi1; l = https: //femmebe.com/media/statact/femmebabe.svg

_dmarc ടെക്സ്റ്റ് N / A. v = dmarc1; p = ഒന്നുമില്ല

സെൻഡന്ലി._ഡോംകീ ടെക്സ്റ്റ് N / A.

ഇപ്പോൾ, പോസ്റ്റ്ഫിക്സിനായി ചില ചില കോൺഫിഗറേഷൻ ചേർക്കേണ്ടതുണ്ട്. ഞങ്ങൾ ചെയ്യേണ്ടത് ഞങ്ങൾ ഡൊമെയ്ൻ നാമം മാറ്റിസ്ഥാപിക്കുന്നുവെന്ന് ഉറപ്പാക്കുക, നിങ്ങൾ ഉപയോഗിക്കുന്ന ഡൊമെയ്ൻ നാമം ഉപയോഗിച്ച് ഞങ്ങൾ മാറ്റിസ്ഥാപിക്കുന്നുവെന്ന് ഉറപ്പാക്കുക എന്നതാണ്. OS- ലേക്ക് ഇൻസ്റ്റാളുചെയ്യുന്നതിന് OS- ലേക്ക് ഇൻസ്റ്റാളുചെയ്യുന്നതിന് ഞങ്ങളുടെ പ്രോജക്റ്റിലെ ഒരു ഡയറക്ടറിയിൽ നമുക്ക് നോക്കാം.

nano config/etc_postfix_main.cf

ഈ വാചകം ഫയലിലേക്ക് ചേർക്കുക

# ഒരു അഭിപ്രായമിട്ട, കൂടുതൽ സമ്പൂർണ്ണ പതിപ്പിനായി /usr/share/postfix/main.cf.dist കാണുക
# ഡെബിയൻ നിർദ്ദിഷ്ട: ഒരു ഫയൽ നാമം വ്യക്തമാക്കുന്നത് ആദ്യത്തേതിന് കാരണമാകും
# ആ ഫയലിന്റെ വരി പേരായി ഉപയോഗിക്കും.  ഡെബിയൻ സ്ഥിരസ്ഥിതി
# / etc / mailname.
# myorigin = / etc / mailname
# കൂട്ടിച്ചേർക്കുന്നു .ഒരു വോർഡൈൻ മുവയുടെ ജോലിയാണ്.
# "കാലതാമസം നേരിട്ട മെയിൽ" മുന്നറിയിപ്പുകൾ സൃഷ്ടിക്കുന്നതിനുള്ള അടുത്ത വരി "
# കാലതാമസം_വേരിംഗ്_ടൈം = 4h
# Http://www.postfix.org/compatibity_readme.html കാണുക - സ്ഥിരസ്ഥിതിയായി 3.6 ആയി
# പുതിയ ഇൻസ്റ്റാളുകൾ.
# Tls പാരാമീറ്ററുകൾ
# മിൽട്ടർ കോൺഫിഗറേഷൻ

അടുത്ത കോൺഫിഗറേഷൻ!

nano config/etc_postfix_master.cf

ഈ വരികൾ ചേർക്കുക:

# 
# പോസ്റ്റ്ഫിക്സ് മാസ്റ്റർ പ്രോസസ്സ് കോൺഫിഗറേഷൻ ഫയൽ.  ഫോർമാറ്റിനെക്കുറിച്ചുള്ള വിശദാംശങ്ങൾക്ക്
# ഫയലിന്റെ (5) മാനുവൽ പേജ് (കമാൻഡ്: "മാൻ 5 മാസ്റ്റർ" അല്ലെങ്കിൽ
# ഓൺ-ലൈൻ: http://www.postfix.org/master.5.html).
# 
# ഈ ഫയൽ എഡിറ്റുചെയ്തതിനുശേഷം "പോസ്റ്റ്ഫിക്സ് റീലോഡ്" എക്സിക്യൂട്ട് ചെയ്യാൻ മറക്കരുത്.
# 
# =============================================================
# സേവന തരം പ്രൈവറ്റ് Inpriv Whoot Wakut wakeup maxproc കമാൻഡ് + ആർട്സ്
# (അതെ) (അതെ) (ഇല്ല) (ഒരിക്കലും) (100)
# =============================================================
# SMTP INET N - Y - 1 പോസ്റ്റ്സ്ക്രീൻ
# smtpd പാസ് - - Y - - SMTPD
# DNSBlobBlog Uniix - - Y - 0 DNSBlog
# tlsproxy unix - - Y - 0 TLSProxy
# ഒന്ന് തിരഞ്ഞെടുക്കുക: ലൂപ്പ്ബാക്ക് ക്ലയന്റുകൾക്കായി മാത്രം സമർപ്പിക്കൽ അല്ലെങ്കിൽ ഏതെങ്കിലും ക്ലയന്റിനായി പ്രാപ്തമാക്കുക.
# 127.0.0.1: പരിചയീയമായ ഐഎൻഇറ്റ് n - y - - smtpd
# -o syslog_name = പോസ്റ്റ്ഫിക്സ് / സമർപ്പിക്കൽ
# -o smtpd_tls_scurity_level = എൻക്രിപ്റ്റ്
# -o smtpd_sasl_at_nable = അതെ
# -o smtpd_tls_അത്ത്_അല്ലെന്ന് = അതെ
# -o smtpd_reject_unlisted_recipient = ഇല്ല
# -o smtpd_client_restictions = $ mua_client_restrications
# -o smtpd_helo_rstrestions = $ mua_helo_resticures
# -o smtpd_sender_rstictions = $ mua_sender_resticures
# -o smtpd_recipient_rstickrigns =
# -o smtpd_relay_rstricks = pertion_sasl_atainticated, നിരസിക്കുന്നു
# -o മിൽട്ടർ_മാക്രോ_ഡെമാൻ_നാമം = ഉത്ഭവിക്കുന്ന
# ഒന്ന് തിരഞ്ഞെടുക്കുക: ലൂപ്പ്ബാക്ക് ക്ലയന്റുകൾക്കായി മാത്രം SMTPS പ്രാപ്തമാക്കുക, അല്ലെങ്കിൽ ഏതെങ്കിലും ക്ലയന്റിനായി.
# 127.0.0.1:SMTPS INET N - Y - - SMTPD
# SMTPS INET N - Y - - SMTPD
# -o syslog_name = പോസ്റ്റ്ഫിക്സ് / SMTPS
# -o smtpd_tls_wrappermome = അതെ
# -o smtpd_sasl_at_nable = അതെ
# -o smtpd_reject_unlisted_recipient = ഇല്ല
# -o smtpd_client_restictions = $ mua_client_restrications
# -o smtpd_helo_rstrestions = $ mua_helo_resticures
# -o smtpd_sender_rstictions = $ mua_sender_resticures
# -o smtpd_recipient_rstickrigns =
# -o smtpd_relay_rstricks = pertion_sasl_atainticated, നിരസിക്കുന്നു
# -o മിൽട്ടർ_മാക്രോ_ഡെമാൻ_നാമം = ഉത്ഭവിക്കുന്ന
# 628 ഇന്നൽ എൻ - y - - QMQPD
# Qmgr Unix n - N 300 1 OQMGR
# -o smtp_helo_timeout = 5 -o smtp_connect_miteout = 5
# 
# ===============================================================
# പോസ്റ്റ് ഫിക്സ് സോഫ്റ്റ്വെയറിലേക്കുള്ള ഇന്റർഫേസുകൾ. മാനുവൽ പരിശോധിക്കുന്നത് ഉറപ്പാക്കുക
# ഏത് ഓപ്ഷനുകൾ ആഗ്രഹിക്കുന്നുവെന്ന് കണ്ടെത്താൻ പോസ്റ്റിക് ഇതര സോഫ്റ്റ്വെയറിന്റെ പേജുകൾ.
# 
# ഇനിപ്പറയുന്നവയിൽ പല സേവനങ്ങളും പോസ്റ്റ്ഫിക്സ് പൈപ്പ് (8) ഡെലിവറി ഉപയോഗിക്കുന്നു
# ഏജന്റ്.  $ {സ്വീകർത്താവിനെക്കുറിച്ചുള്ള വിവരങ്ങൾക്കായി പൈപ്പ് (8) മാൻ പേജ് കാണുക
# മറ്റ് സന്ദേശ എൻവലപ്പ് ഓപ്ഷനുകളും.
# ===============================================================
# 
# മെയിൽ ഡ്രോപ്പ്. വിശദാംശങ്ങൾക്ക് പോസ്റ്റ്ഫിക്സ് മെൽഡ്രോപ്പ്_ റീഡ്മെ ഫയൽ കാണുക.
# Main.cf- ൽ വ്യക്തമാക്കുക: MymdrOp_Destinging_recipient_ളിപ്പ് = 1
# 
# 
# ===============================================================
# 
# സമീപകാല സിറസ് പതിപ്പുകൾ നിലവിലുള്ള "എൽഎംടിപി" മാസ്റ്റർ പിഎഫ്എഫ് എൻട്രി ഉപയോഗിക്കാൻ കഴിയും.
# 
# Creeus.conf ൽ വ്യക്തമാക്കുക:
# Lmtp cmd = "lmpd -" കേൾക്കുക = "ലോക്കൽഹോസ്റ്റ്: എൽഎംടിപി" പ്രോട്ടോ = ടിസിപി 4
# 
# ഇനിപ്പറയുന്നവയിൽ ഒന്നോ അതിലധികമോ മെയിൻ. സിയിൽ വ്യക്തമാക്കുക:
# mymobk_transport = lmp: ഇന്നത്ത്: ലോക്കൽഹോസ്റ്റ്
# വെർച്വൽ_ട്രാൻസ്പോർട്ട് = lmp: ഇന്നത്ത്: ലോക്കൽഹോസ്റ്റ്
# 
# ===============================================================
# 
# സൈറസ് 2.1.5 (അമോസ് ഗ ou ക്സ്)
# Main.cf- ൽ വ്യക്തമാക്കുക: creus_destion_recipient_ളിമിറ്റ് = 1
# 
# CYREUS UNIXT - N N - - പൈപ്പ്
# ഫ്ലാഗുകൾ = DRX ഉപയോക്താവ് = cires argv = / cirus / bin / reliel -r $ {അയച്ചയാൾ} -m {വിപുലീകരണ}
# 
# ===============================================================
# സൈറസ് വഴി ഡെലിവറിയുടെ പഴയ ഉദാഹരണം.
# 
# പഴയ-സൈറസ് യുണിക്സ് - എൻ n - - പൈപ്പ്
# ഫ്ലാഗുകൾ = ആർ ഉപയോക്താവ് = cires argv = / cires / bin / tript -e -m $ {Auff idet {ഉപയോക്താവ്}
# 
# ===============================================================
# 
# കോൺഫിഗറേഷൻ വിശദാംശങ്ങൾക്കായി പോസ്റ്റ്ഫിക്സ് ucp_readme ഫയൽ കാണുക.
# 
# 
# മറ്റ് ബാഹ്യ ഡെലിവറി രീതികൾ.
# 

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

nano config/etc_default_opendkim

ഈ വരികൾ ചേർക്കുക:

# കുറിപ്പ്: ഇതൊരു ലെഗസി കോൺഫിഗറേഷൻ ഫയലാണ്. ഇത് ഒൻനെൻഡ്കിം ഉപയോഗിക്കുന്നില്ല
# systemd സേവനം. അനുബന്ധ കോൺഫിഗറേഷൻ പാരാമീറ്ററുകൾ ഉപയോഗിക്കുക
# /etc/opendkim.conf പകരം.
# 
# മുമ്പ്, ഒരാൾ ഇവിടെ സ്ഥിരസ്ഥിതി ക്രമീകരണങ്ങൾ എഡിറ്റുചെയ്യും, തുടർന്ന് എക്സിക്യൂട്ട് ചെയ്യുക
# /lib/opendkim/opendkim.service. സിസ്റ്റംഡ് അസാധുവാക്കൽ ഫയലുകൾ സൃഷ്ടിക്കുന്നതിന്
# /ec/systemd/system/opendkim.service.d/oraverride.conf കൂടാതെ
# /etc/tmpfiles.d/opendkim.conf. ഇത് ഇപ്പോഴും സാധ്യമാകുമ്പോൾ, ഇപ്പോൾ
# /etc/opendkim.conf- ൽ നേരിട്ട് ക്രമീകരിക്കാൻ ശുപാർശ ചെയ്യുന്നു.
# 
# Deamon_opts = ""
# ഒരു യുണിക്സ് സോക്കറ്റ് ഉപയോഗിക്കുന്നതിന് / var / spool / porkfix / റൺ / ഓപ്പൺകീം എന്നിവയിലേക്ക് മാറ്റുക
# ഒരു ക്രോട്ടിലെ പോസ്റ്റ്ഫിക്സ്:
# റുണ്ടിർ = / var / spool / പോസ്റ്റ്ഫിക്സ് / റൺ / ഓപ്പെം
# 
# ഒരു ഇതര സോക്കറ്റ് വ്യക്തമാക്കാനുള്ള നമ്പർ
# Opendkim.conf- ലെ ഒരു സോക്കറ്റ് മൂല്യത്തെ അസാധുവാക്കുമെന്നത് ശ്രദ്ധിക്കുക
# സ്ഥിരസ്ഥിതി:
# പോർട്ട് 54321 ലെ എല്ലാ ഇന്റർഫേസുകളും ശ്രദ്ധിക്കുക:
# Intl: 54321
# പോർട്ട് 12345 പോർട്ട് ലൂപ്പ്ബാക്ക് ശ്രദ്ധിക്കുക:
# Intn: 12345 @ ലോക്കൽഹോസ്റ്റ്
# പോർട്ട് 12345 ന് 192.0.2.1 ശ്രദ്ധിക്കുക:
# Inating: 12345@192.2.1

nano config/etc_dovecot_conf.d_10-master.conf

ഈ വരികൾ ചേർക്കുക:

# Faceffor_process_limit = 100
# Fay_client_ളിമിറ്റ് = 1000
# സേവന പ്രക്രിയകൾക്കുള്ള സ്ഥിരസ്ഥിതി വിഎസ്ഇ (വെർച്വൽ മെമ്മറി വലുപ്പം) പരിധി. ഇത് പ്രധാനമായും
# മെമ്മറി കഴിക്കുന്നതിനുമുമ്പ് മെമ്മറി ലജ്ജിക്കുന്ന പ്രോസസ്സുകൾ പിടിക്കാനും കൊല്ലാനും ഉദ്ദേശിച്ചുള്ളതാണ്
# എല്ലാം.
# Faceca_vsz_limit = 256 മി
# ലോഗിൻ ഉപയോക്താവ് ലോഗിൻ പ്രോസസ്സുകൾ ആന്തരികമായി ഉപയോഗിക്കുന്നു. ഇതാണ് ഏറ്റവും വിശ്വസനീയമായത്
# ഡോർകോട്ട് സിസ്റ്റത്തിലെ ഉപയോക്താവ്. അതിൽ ഒരു കാര്യത്തിലും പ്രവേശനമുണ്ടാകരുത്.
# Faceca_login_user = Doovenul
# ആന്തരിക ഉപയോക്താവ് ചികിത്സിക്കാത്ത പ്രക്രിയകൾ ഉപയോഗിക്കുന്നു. അതിൽ നിന്ന് വേറിട്ടതായിരിക്കണം
# ലോഗിൻ ഉപയോക്താവ്, അതിനാൽ ലോഗിൻ പ്രോസസ്സുകൾക്ക് മറ്റ് പ്രക്രിയകളെ ശല്യപ്പെടുത്താൻ കഴിയില്ല.
# Defay_internal_user = dovecot
    # പോർട്ട് = 143
    # പോർട്ട് = 993
    # SSL = അതെ
  # ഒരു പുതിയ പ്രക്രിയ ആരംഭിക്കുന്നതിന് മുമ്പ് കൈകാര്യം ചെയ്യേണ്ട കണക്ഷനുകളുടെ എണ്ണം. സാധാരണ
  # ഉപയോഗപ്രദമായ ഒരേ ഉപയോഗപ്രദമായ മൂല്യങ്ങൾ 0 (പരിധിയില്ലാത്തത്) അല്ലെങ്കിൽ 1. 1 കൂടുതൽ സുരക്ഷിതമാണ്, പക്ഷേ 0
  # വേഗതയേറിയതാണ്. <poc / Wiki / loginprocess.gxt>
  # curaver_count = 1
  # കൂടുതൽ കണക്ഷനുകൾക്കായി എല്ലായ്പ്പോഴും കാത്തിരിക്കേണ്ട പ്രക്രിയകളുടെ എണ്ണം.
  # P പ്രോസസ്_മിൻ_വെയൽ = 0
  # നിങ്ങൾ Server_count = 0 സജ്ജമാക്കുകയാണെങ്കിൽ, നിങ്ങൾ ഇത് വളർത്തേണ്ടതുണ്ട്.
  # vsz_ലിമിറ്റ് = $ സ്ഥിരസ്ഥിതി_വിസ്സ്_ലിമിറ്റ്
    # പോർട്ട് = 110
    # പോർട്ട് = 995
    # SSL = അതെ
    # പോർട്ട് = 587
  # നിങ്ങൾക്ക് മുകളിലുള്ള യുണിക്സ് സോക്കറ്റ് ഉപയോഗിക്കാൻ കഴിയുന്നില്ലെങ്കിൽ മാത്രം ഇന്നറ്റ് ശ്രോതാവ് സൃഷ്ടിക്കുക
  # inet_listener lmp ttp {
    # മുഴുവൻ ഇന്റർനെറ്റിനും LMTP ദൃശ്യമാക്കുന്നത് ഒഴിവാക്കുക
    # വിലാസം =
    # പോർട്ട് =
  # }
  # മെമ്മറിയിൽ ഭൂരിഭാഗവും mmap () ing ഫയലുകളിലേക്ക് പോകുന്നു. നിങ്ങൾ ഇത് വർദ്ധിപ്പിക്കേണ്ടതുണ്ട്
  # നിങ്ങൾക്ക് വലിയ മെയിൽബോക്സുകൾ ഉണ്ടെങ്കിൽ പരിമിതപ്പെടുത്തുക.
  # vsz_ലിമിറ്റ് = $ സ്ഥിരസ്ഥിതി_വിസ്സ്_ലിമിറ്റ്
  # പരമാവധി. IMAP പ്രോസസ്സുകളുടെ എണ്ണം (കണക്ഷനുകൾ)
  # പ്രോസസ്സ്_ലിമിറ്റ് = 1024
  # പരമാവധി. പോപ്പ് 3 പ്രോസസുകളുടെ എണ്ണം (കണക്ഷനുകൾ)
  # പ്രോസസ്സ്_ലിമിറ്റ് = 1024
  # പരമാവധി. SMTP സമർപ്പിക്കൽ പ്രോസസുകളുടെ എണ്ണം (കണക്ഷനുകൾ)
  # പ്രോസസ്സ്_ലിമിറ്റ് = 1024
  # auth_sock_ath സ്ഥിരസ്ഥിതിയായി ഈ യൂസർഡ്ബി സോക്കറ്റിലേക്ക് വിരൽ ചൂണ്ടുന്നു. ഇത് സാധാരണമാണ്
  # ഉള്ളത് ഡോർകോട്ട്-എൽഡിഎ, ഡോവെഡ് എം, ഒരുപക്ഷേ ഇമാപ്പ് പ്രോസസ്സ് മുതലായവ ഉപയോഗിക്കുന്നു
  # ഈ സോക്കറ്റിലേക്കുള്ള പൂർണ്ണ അനുമതികൾ എല്ലാ ഉപയോക്തൃനാമങ്ങളുടെയും ഒരു ലിസ്റ്റ് നേടാൻ കഴിയും
  # എല്ലാവരുടെയും യൂസർഡ്ബി ലുക്കപ്പുകളുടെ ഫലങ്ങൾ നേടുക.
  # 
  # സ്ഥിരസ്ഥിതി 0666 മോഡ് സോക്കറ്റിലേക്ക് കണക്റ്റുചെയ്യാൻ ആരെയും അനുവദിക്കുന്നു, പക്ഷേ
  # Userdb തിരയൽ erquedb ഒരു "യുഐഡി" ഫീൽഡ് നൽകുന്നുവെങ്കിൽ മാത്രമേ വിജയിക്കൂ
  # കോളർ പ്രോസസിന്റെ യുഐഡിയുമായി പൊരുത്തപ്പെടുന്നു. കോളറിന്റെ യുഐഡി അല്ലെങ്കിൽ ജിഐഡി പൊരുത്തപ്പെടുന്നുണ്ടെങ്കിൽ
  # സോക്കറ്റിന്റെ യുഐഡി അല്ലെങ്കിൽ ജിഐഡി ലുക്ക് വിജയിക്കുന്നു. മറ്റെന്തെങ്കിലും പരാജയത്തിന് കാരണമാകുന്നു.
  # 
  # എല്ലാ ഉപയോക്താക്കളെയും നോക്കുന്നതിന് കോളറിന് പൂർണ്ണ അനുമതികൾ നൽകുന്നതിന്, മോഡ് സജ്ജമാക്കുക
  # 0666 നേക്കാൾ മറ്റെന്തെങ്കിലും, കേർണൽ നടപ്പിലാക്കാൻ ഡോവ്കോട്ട് അനുവദിക്കുന്നു
  # അനുമതികൾ (ഉദാ. 0777 എല്ലാ എല്ലാ അനുമതികളും അനുവദിക്കുന്നു).
  # Auth വർക്കർ പ്രക്രിയ സ്ഥിരസ്ഥിതിയായി റൂട്ടായി പ്രവർത്തിപ്പിക്കുന്നു, അതുവഴി പ്രവേശിക്കാൻ കഴിയും
  # / etc / ഷാഡോ. ഇത് ആവശ്യമില്ലെങ്കിൽ, ഉപയോക്താവിനെ മാറ്റണം
  # $ bion_interneral_user.
  # ഉപയോക്താവ് = റൂട്ട്
  # ഡിഡ് പ്രോക്സി ഉപയോഗിക്കുകയാണെങ്കിൽ, മെയിൽ പ്രോസസ്സുകൾക്ക് അതിന്റെ സോക്കറ്റിലേക്ക് ആക്സസ് ഉണ്ടായിരിക്കണം.
  # ഉദാഹരണത്തിന്: മോഡ് = 0660, ഗ്രൂപ്പ് = vmail, ആഗോള മെയിൽ_കോസ്_ഗ്രൂപ്പ് = vmail
    # മോഡ് = 0600
    # ഉപയോക്താവ് =
    # ഗ്രൂപ്പ് =

നിങ്ങൾ തിരഞ്ഞെടുത്ത ഡൊമെയ്ൻ ഉപയോഗിച്ച് ഈ ഫയലുകളിലെല്ലാം ഡൊമെയ്ൻ മാറ്റിസ്ഥാപിക്കുന്നത് ഉറപ്പാക്കുക. അടുത്ത ഫയൽ, ഡൊവ്കോട്ടിന്റെ കോൺഫിഗറേഷൻ,

nano config/etc_dovecot_dovecot

ഈ വരികൾ ചേർക്കുക

## ഡോർകോട്ട് കോൺഫിഗറേഷൻ ഫയൽ
# നിങ്ങൾ തിരക്കിലാണെങ്കിൽ, http://wiki2.dovecot.org/qickConficuration കാണുക
# മാറിയ ക്രമീകരണങ്ങളുടെ "DOWEConf -n" കമാൻഡ് നൽകുന്നു. അത് ഉപയോഗിക്കുക
# ഡോർകോട്ട് മെയിലിംഗ് ലിസ്റ്റിലേക്ക് പോസ്റ്റുചെയ്യുമ്പോൾ ഫയലുകൾ പകർത്താനും ഒട്ടിക്കുന്ന ഫയലുകൾ.
# '# 'പ്രതീകവും എല്ലാം അഭിപ്രായങ്ങളായി കണക്കാക്കപ്പെടുന്നതിനുശേഷം എല്ലാം. അധിക ഇടങ്ങൾ
# ടാബുകൾ അവഗണിക്കപ്പെടും. നിങ്ങൾക്ക് ഇവ രണ്ടും വ്യക്തമായി ഉപയോഗിക്കാൻ താൽപ്പര്യമുണ്ടെങ്കിൽ, ഇടുക
# value inside quotes, eg.: key = "# ചാർ, ട്രെയിലിംഗ് വൈറ്റ്സ്പെയ്സ് "
# മിക്കതും (എന്നാൽ എല്ലാം അല്ല) ക്രമീകരണങ്ങൾ വ്യത്യസ്ത പ്രോട്ടോക്കോളുകളും കൂടാതെ / അല്ലെങ്കിൽ അല്ലെങ്കിൽ
# ഉദാഹരണത്തിന് വിഭാഗങ്ങൾക്കുള്ളിൽ ക്രമീകരണങ്ങൾ സ്ഥാപിച്ചുകൊണ്ട് ഉറവിട / ഉദ്ദിഷ്ടസ്ഥാന ഐ.ഐ.പി.
# പ്രോട്ടോക്കോൾ ഇമാപ്പ് {, ലോക്കൽ 127.0.0.1}}, വിദൂര 10.0.0.0/8}}
# ഓരോ ക്രമീകരണത്തിനും സ്ഥിരസ്ഥിതി മൂല്യങ്ങൾ കാണിക്കുന്നു, ഇത് അടച്ചില്ല
# അവ. ഇവ ഇതിന്റെ അപവാദങ്ങളാണ്: വിഭാഗങ്ങളൊന്നുമില്ല (ഉദാ. നെയിംസ്പെയ്സ്})
# അല്ലെങ്കിൽ പ്ലഗിൻ ക്രമീകരണങ്ങൾ സ്ഥിരസ്ഥിതിയായി ചേർത്തു, അവ ഉദാഹരണങ്ങളായി മാത്രം പട്ടികപ്പെടുത്തിയിട്ടുണ്ട്.
# കോൺഫിഗർ അടിസ്ഥാനമാക്കിയുള്ള യഥാർത്ഥ സ്ഥിരസ്ഥിതികൾ ഉള്ള ഉദാഹരണങ്ങളും പാത്തുകൾ മാത്രമാണ്
# ഓപ്ഷനുകൾ. ഇവിടെ ലിസ്റ്റുചെയ്തിരിക്കുന്ന പാതകൾ --prefix = / usr
# --sysconfdir = / etc - etclocalstatir = / var
# ഇൻസ്റ്റാളുചെയ്ത പ്രോട്ടോക്കോളുകൾ പ്രാപ്തമാക്കുക
# കണക്ഷനുകൾക്കായി കേൾക്കുന്ന ഐപിഎസ് അല്ലെങ്കിൽ ഹോസ്റ്റുകളുടെ ഒരു കോമ വേർതിരിച്ച ലിസ്റ്റ്.
# "*" എല്ലാ IPv4 ഇന്റർഫേസുകളിലും "::" എല്ലാ ഐപിവി 6 ഇന്റർഫേസുകളിലും ശ്രദ്ധിക്കുന്നു.
# സ്ഥിരസ്ഥിതി ഇതര പോർട്ടുകൾ അല്ലെങ്കിൽ കൂടുതൽ സങ്കീർണ്ണമായ എന്തെങ്കിലും വ്യക്തമാക്കണമെങ്കിൽ,
# CONF.D / MART.CONF എഡിറ്റുചെയ്യുക.
# ശ്രദ്ധിക്കൂ = *, ::
# റൺടൈം ഡാറ്റ സംഭരിക്കേണ്ട അടിസ്ഥാന ഡയറക്ടറി.
# Base_dir = / var / run / dovecot /
# ഈ ഉദാഹരണത്തിന്റെ പേര്. മൾട്ടി-ഇൻസ്റ്റൻസ് സെറ്റപ്പ് ഡൊവാഡ്മും മറ്റ് കമാൻഡുകളും
# ഏത് ഉദാഹരണമാണ് ഉപയോഗിക്കുന്നതെന്ന് തിരഞ്ഞെടുക്കാൻ -i <trans_name> ഉപയോഗിക്കാൻ കഴിയും (ഒരു ബദൽ
# -c <config_path> ലേക്ക്. ഉദാത്തൊരു പ്രോസസുകളിലും ഉദാഹരണ നാമവും ചേർത്തു
# പിഎസ് .ട്ട്പുട്ടിൽ.
# InstaS_name = Dovecot
# ക്ലയന്റുകൾക്കായി ഗ്രീറ്റിംഗ് സന്ദേശം.
# ലോഗിൻ_ഗ്രിറ്റിംഗ് = ഡോവെക്കോട്ട് തയ്യാറാണ്.
# വിശ്വസനീയമായ നെറ്റ്വർക്ക് ശ്രേണികളുടെ സ്ഥലം വേർതിരിച്ച ലിസ്റ്റ്. ഇവയിൽ നിന്നുള്ള കണക്ഷനുകൾ
# അവരുടെ ഐപി വിലാസങ്ങളും പോർട്ടുകളും അസാധുവാക്കാൻ ഐപിഎസിനെ അനുവദിച്ചിരിക്കുന്നു (ലോഗിംഗിനായി കൂടാതെ
# പ്രാമാണീകരണ പരിശോധനയ്ക്കായി). അപ്രാപ്തമാക്കുക_പ്ലായിക്റ്റെക്സ്_അത്തും അവഗണിക്കപ്പെടും
# ഈ നെറ്റ്വർക്കുകൾ. സാധാരണഗതിയിൽ നിങ്ങളുടെ IMAP പ്രോക്സി സെർവറുകൾ ഇവിടെ വ്യക്തമാക്കുന്നു.
# login_trusted_networks =
# ബഹിരാകാശത്തെ വേർതിരിച്ച ലോഗിൻ ആക്സസ് ചെക്ക് സോക്കറ്റുകൾ (ഉദാ. TCPWRAP)
# login_access_sockets =
# പ്രോക്സി_മൈബെ = അതെ പ്രോക്സി ലക്ഷ്യസ്ഥാനം ഈ ഐപിഎസിനുമായി പൊരുത്തപ്പെടുന്നുവെങ്കിൽ, ചെയ്യരുത്
# പ്രോക്സിംഗ്. ഇത് സാധാരണയായി ആവശ്യമില്ല, പക്ഷേ ലക്ഷ്യസ്ഥാനം എങ്കിൽ ഉപയോഗപ്രദമാകാം
# IP E.G ആണ്. ഒരു ലോഡ് ബാലൻസറുടെ ഐപി.
# Auth_proxy_gen
# കൂടുതൽ വെർബോസ് പ്രോസസ്സ് ശീർഷകങ്ങൾ കാണിക്കുക (പിഎസ്). നിലവിൽ ഉപയോക്തൃനാമവും കാണിക്കുന്നു
# ഐപി വിലാസം. ഇമിപ്പ് പ്രോസസ്സുകൾ ഉപയോഗിക്കുന്നതു കാണുന്നതിന് ഉപയോഗപ്രദമാണ്
# (ഉദാ. പങ്കിട്ട മെയിൽബോക്സുകൾ അല്ലെങ്കിൽ ഒരേ യുഐഡി ഒന്നിലധികം അക്കൗണ്ടുകൾക്കായി ഉപയോഗിക്കുന്നുവെങ്കിൽ).
# verbos_proctitle = ഇല്ല
# ഡൊവെകോട്ട് മാസ്റ്റർ പ്രക്രിയ അടച്ചുപൂട്ടുമ്പോൾ എല്ലാ പ്രക്രിയകളും കൊല്ലപ്പെടുമോ?
# ഇത് "ഇല്ല" എന്നതിനർത്ഥം ഡൊവെകോട്ട് ഇല്ലാതെ അപ്ഗ്രേഡുചെയ്യാനാകും എന്നാണ്
# നിലവിലുള്ള ക്ലയന്റ് കണക്ഷനുകൾ അടയ്ക്കുന്നതിന് നിർബന്ധിക്കുന്നു (അത് ആകാം
# നവീകരണം e.g ആണെങ്കിൽ ഒരു പ്രശ്നം. ഒരു സുരക്ഷാ പരിഹാരം കാരണം).
# suxdown_clients = അതെ
# പൂജ്യമല്ലാത്തത്, ഡോവെഡ്എം സെർവറിലേക്കുള്ള ഈ നിരവധി കണക്ഷനുകൾ വഴി മെയിൽ കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുക,
# ഒരേ പ്രക്രിയയിൽ നേരിട്ട് പ്രവർത്തിപ്പിക്കുന്നതിനുപകരം.
# doveadm_worker_count = 0
# യുണിക്സ് സോക്കറ്റ് അല്ലെങ്കിൽ ഹോസ്റ്റ്: ഡൊവാഡ് എം സെർവറിലേക്ക് കണക്റ്റുചെയ്യാൻ പോർട്ട് ഉപയോഗിക്കുന്നു
# doveadm_sockoct_ath = ഡോവെഡ്എം-സെർവർ
# ഡൊവ്കോട്ടിൽ സംരക്ഷിച്ചിരിക്കുന്ന പരിസ്ഥിതി വേരിയബിളുകളുടെ സ്ഥലം വേർതിരിച്ച ലിസ്റ്റ്
# സ്റ്റാർട്ടപ്പ് ചെയ്ത് അതിന്റെ എല്ലാ ശിശു പ്രക്രിയകളിലേക്കും കൈമാറി. നിങ്ങൾക്ക് നൽകാം
# കീ = എല്ലായ്പ്പോഴും നിർദ്ദിഷ്ട ക്രമീകരണങ്ങൾ സജ്ജമാക്കുന്നതിനുള്ള മൂല്യം ജോഡികൾ.
# Import_envinininment = tz
## 
## നിഘണ്ടു സെർവർ ക്രമീകരണങ്ങൾ
## 
# കീ = മൂല്യ ലിസ്റ്റുകൾ സംഭരിക്കാൻ നിഘണ്ടു ഉപയോഗിക്കാം. ഇത് നിരവധി ഉപയോഗിക്കുന്നു
# പ്ലഗിനുകൾ. നിഘണ്ടു നേരിട്ട് ആക്സസ്സുചെയ്യാനാകും അല്ലെങ്കിൽ a
# നിഘണ്ടു സെർവർ. ഇനിപ്പറയുന്ന ഡിആർഎസ് ബ്ലോക്ക് മാപ്പുകൾ നിഘണ്ടു യുആർഐകൾക്ക്
# സെർവർ ഉപയോഗിക്കുമ്പോൾ. ഇവ ഫോർമാറ്റിൽ URI- കൾ ഉപയോഗിച്ച് പരാമർശിക്കാം
# "പ്രോക്സി :: <name>".
  # ക്വാട്ട = Mysql: /etc/dovecot/doveCot-sql.conf.conf
# യഥാർത്ഥ കോൺഫിഗറേഷൻ മിക്കതും ചുവടെ ഉൾപ്പെടുന്നു. ഫയൽനാമങ്ങൾ
# ആദ്യം അവരുടെ ASCII മൂല്യം അനുസരിച്ച് ആ ക്രമത്തിൽ പാഴ്സുചെയ്തു. 00-പ്രിഫിക്സുകൾ
# ഓർഡറിംഗ് മനസിലാക്കാൻ എളുപ്പമാക്കാൻ ഫയൽനാമങ്ങളിൽ ഉദ്ദേശിച്ചുള്ളതാണ്.
# ഒരു പിശക് ഫയൽ ഒരു പിശക് നൽകാതെ ഉൾപ്പെടുത്താൻ ശ്രമിക്കുന്നു
# ഇത് കണ്ടെത്തിയില്ല:
# എല്ലാ ഇൻപുട്ട് കണക്ഷനുകളും കേൾക്കാൻ ഡൊവെക്കോട്ടിനെ അനുവദിക്കുന്നു (ipv4 / ipv6)

ഡോർകോട്ട് ഉപയോക്താവിനായി ഒരു പാസ്വേഡ് ചേർക്കുക:

nano config/etc_dovecot_passwd

ഫയലിന്റെ ആദ്യ ഭാഗം, കോളനിന് മുമ്പുള്ള ഉപയോക്തൃനാമമാണ്. അവസാന ഭാഗം, "നിങ്ങളുടെ പാസ്വേഡ്", നിങ്ങളുടെ മെയിൽ സെർവർ നൽകാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്ന പാസ്വേഡിനെ സൂചിപ്പിക്കുന്നു.

team:{plain}yourpassword

അടുത്തതായി, ഓപ്പൺകിം കോൺഫിഗറേഷൻ

nano config/etc_opendkim.conf

ഈ വരികൾ ചേർക്കുക:

# ഒപ്പിടുന്നതിനും പരിശോധിക്കുന്നതിനുമുള്ള അടിസ്ഥാന കോൺഫിഗറേഷനാണ് ഇത്. ഇത് എളുപ്പത്തിൽ ആകാം
# ഒരു അടിസ്ഥാന ഇൻസ്റ്റാളേഷന് അനുയോജ്യമായ രീതിയിൽ പൊരുത്തപ്പെട്ടു. Opendkim.conf (5) കാണുക
# /usr/share/doc/opendkim/examendkim.conf.sample പൂർത്തിയായി
# ലഭ്യമായ കോൺഫിഗറേഷൻ പാരാമീറ്ററുകളുടെ ഡോക്യുമെന്റേഷൻ.
# ലോഗ്സ് ഇല്ല
# സാധാരണ ഒപ്പിട്ടതും സ്ഥിരീകരണ പാരാമീറ്ററുകളും. ഡെബിയനിൽ, തലക്കെട്ട് "എന്നതിൽ നിന്ന്
# അമിതമായി, കാരണം ഇത് പലപ്പോഴും പ്രശസ്തി സംവിധാനങ്ങളുടെ ഐഡന്റിറ്റി കീയാണ്
# അങ്ങനെ സുരക്ഷാ സെൻസിറ്റീവ്.
# ഡൊമെയ്ൻ, സെലക്ടർ, കീ (ആവശ്യമാണ്) സൈനിംഗ്. ഉദാഹരണത്തിന്, സൈൻ ഇൻ ചെയ്യുക
# സെലക്ടർ "2020" (2020._ommainkey.example.com) ഉപയോഗിച്ച് "ഉദാഹരണം.
# /etc/dkimkeys/example.private ൽ സംഭരിച്ചിരിക്കുന്ന സ്വകാര്യ കീ ഉപയോഗിക്കുന്നു. കൂടുതൽ ഗ്രാനുലാർ
# സജ്ജീകരണ ഓപ്ഷനുകൾ /sr/share/doc/opendkim/readme.opendkim- ൽ കാണാം.
# ഡൊമെയ്ൻ ഉദാഹരണം
# സെലക്ടർ 2020
# കീഫൈൽ /etc/dkimkeys/example.private
# ഡെബിയനിൽ, ഒൻഎൻഡ്കിം ഉപയോക്താവായി "ഓപെൻഡ്കിം" ആയി പ്രവർത്തിക്കുന്നു. എപ്പോൾ 007 ന്റെ അമാസ്കാൽ ആവശ്യമാണ്
# പ്രത്യേകാവകാശമെന്ന നിലയിൽ സോക്കറ്റ് ആക്സസ് ചെയ്യുന്ന MTAS ഉപയോഗിച്ച് ഒരു പ്രാദേശിക സോക്കറ്റ് ഉപയോഗിക്കുന്നു
# ഉപയോക്താവ് (ഉദാഹരണത്തിന്, പോസ്റ്റ്ഫിക്സ്). ഗ്രൂപ്പിലേക്ക് നിങ്ങൾ ഉപയോക്താവ് "പോസ്റ്റ്ഫിക്സ്" ചേർക്കേണ്ടതുണ്ട്
# ആ സാഹചര്യത്തിൽ "ഓപെൻഡ്കിം".
# എംടിഎ കണക്ഷനുള്ള സോക്കറ്റ് (ആവശ്യമാണ്). എംടിഎ ഒരു ക്രോട്ട് ജയിലിനുള്ളിലാണെങ്കിൽ,
# സോക്കറ്റ് ആക്സസ് ചെയ്യാൻ കഴിയുമെന്ന് ഉറപ്പാക്കണം. ഡെബിയനിൽ, പോസ്റ്റ്ഫിക്സ് പ്രവർത്തിക്കുന്നു
# / var / spool / പോസ്റ്റ്ഫിക്സിലെ ഒരു ക്രോട്ട്, അതിനാൽ ഒരു യുണിക്സ് സോക്കറ്റ് ആയിരിക്കണം
# ചുവടെയുള്ള അവസാന വരിയിൽ കാണിച്ചിരിക്കുന്നതുപോലെ ക്രമീകരിച്ചിരിക്കുന്നു.
# സോക്കറ്റ് ലോക്കൽ: /run/opendkim/opendkim.sock
# സോക്കറ്റ് ഇനെറ്റ്: 8891 @ ലോക്കൽഹോസ്റ്റ്
# സോക്കറ്റ് ഇസത്ത്: 8891
# സ്ഥിരീകരിക്കുന്നതിനേക്കാൾ ഒപ്പിടാനുള്ള ഹോസ്റ്റുകൾ, സ്ഥിരസ്ഥിതി 127.0.0.1 ആണ്. കാണുക
# കൂടുതൽ വിവരങ്ങൾക്ക് ഓപോണ്ടിം (8) പ്രവർത്തന വിഭാഗം.
# ആന്തരികമോന്റോംസ് 192.168.0/16, 10.0.0.0/8, 172.16.0/12
# ട്രസ്റ്റ് ആങ്കർ DNSSEC പ്രാപ്തമാക്കുന്നു. ഡെബിയനിൽ, ട്രസ്റ്റ് ആങ്കർ ഫയൽ നൽകിയിട്ടുണ്ട്
# പാക്കേജ് ഡിഎൻഎസ്-റൂട്ട്-ഡാറ്റ പ്രകാരം.
# നെയിംസർവറുകൾ 127.0.0.1
# സന്ദേശങ്ങളിൽ പ്രവേശിക്കാൻ ഉപയോഗിക്കുന്ന കീകൾക്കായുള്ള വിലാസങ്ങളിൽ നിന്ന് മാപ്പ് ഡൊമെയ്നുകൾ
# മെയിൽ ഒപ്പിടണം എന്ന ആന്തരിക ഹോസ്റ്റുകളുടെ ഒരു കൂട്ടം

nano config/etc_default_opendkim

ഈ വരികൾ ചേർക്കുക

# കുറിപ്പ്: ഇതൊരു ലെഗസി കോൺഫിഗറേഷൻ ഫയലാണ്. ഇത് ഒൻനെൻഡ്കിം ഉപയോഗിക്കുന്നില്ല
# systemd സേവനം. അനുബന്ധ കോൺഫിഗറേഷൻ പാരാമീറ്ററുകൾ ഉപയോഗിക്കുക
# /etc/opendkim.conf പകരം.
# 
# മുമ്പ്, ഒരാൾ ഇവിടെ സ്ഥിരസ്ഥിതി ക്രമീകരണങ്ങൾ എഡിറ്റുചെയ്യും, തുടർന്ന് എക്സിക്യൂട്ട് ചെയ്യുക
# /lib/opendkim/opendkim.service. സിസ്റ്റംഡ് അസാധുവാക്കൽ ഫയലുകൾ സൃഷ്ടിക്കുന്നതിന്
# /ec/systemd/system/opendkim.service.d/oraverride.conf കൂടാതെ
# /etc/tmpfiles.d/opendkim.conf. ഇത് ഇപ്പോഴും സാധ്യമാകുമ്പോൾ, ഇപ്പോൾ
# /etc/opendkim.conf- ൽ നേരിട്ട് ക്രമീകരിക്കാൻ ശുപാർശ ചെയ്യുന്നു.
# 
# Deamon_opts = ""
# ഒരു യുണിക്സ് സോക്കറ്റ് ഉപയോഗിക്കുന്നതിന് / var / spool / porkfix / റൺ / ഓപ്പൺകീം എന്നിവയിലേക്ക് മാറ്റുക
# ഒരു ക്രോട്ടിലെ പോസ്റ്റ്ഫിക്സ്:
# റുണ്ടിർ = / var / spool / പോസ്റ്റ്ഫിക്സ് / റൺ / ഓപ്പെം
# 
# ഒരു ഇതര സോക്കറ്റ് വ്യക്തമാക്കാനുള്ള നമ്പർ
# Opendkim.conf- ലെ ഒരു സോക്കറ്റ് മൂല്യത്തെ അസാധുവാക്കുമെന്നത് ശ്രദ്ധിക്കുക
# സ്ഥിരസ്ഥിതി:
# പോർട്ട് 54321 ലെ എല്ലാ ഇന്റർഫേസുകളും ശ്രദ്ധിക്കുക:
# Intl: 54321
# പോർട്ട് 12345 പോർട്ട് ലൂപ്പ്ബാക്ക് ശ്രദ്ധിക്കുക:
# Intn: 12345 @ ലോക്കൽഹോസ്റ്റ്
# പോർട്ട് 12345 ന് 192.0.2.1 ശ്രദ്ധിക്കുക:
# Inating: 12345@192.2.1

ഞങ്ങളുടെ പോസ്റ്റ്ഫിക്സ് സെർവർ സജ്ജീകരിക്കാൻ ഞങ്ങൾ തയ്യാറാകുമ്പോൾ, ഉചിതമായ ഡൊമെയ്ൻ നാമം ഉൾച്ചേർത്ത് ഞങ്ങൾ ചുവടെയുള്ള കോഡ് പ്രവർത്തിപ്പിക്കും. ഒരു സ്ക്രിപ്റ്റ് സൃഷ്ടിച്ചുകൊണ്ട് ആരംഭിക്കുക

touch scripts/postfixsetup
sudo chmod a+x scripts/postfixsetup
nano scripts/postfixsetup

ഇപ്പോൾ, നാനോയിൽ, ടെക്സ്റ്റ് എഡിറ്റർ, ഈ ഫയൽ എഡിറ്റുചെയ്യുക അതിനാൽ ഇത് semebabe.com ന് പകരം നിങ്ങളുടെ ഡൊമെയ്ൻ നാമം ഉൾപ്പെടുന്നു.

# ! / ബിൻ / ബാഷ്
# പോസ്റ്റ്ഫിക്സ് സജ്ജമാക്കുക

ഇപ്പോൾ, പോസ്റ്റ്ഫിക്സ്, ഓപ്പൺകീം, ഡൊവ്കോട്ട് എന്നിവ ക്രമീകരിക്കുന്നതിന് പൂർത്തിയാക്കിയ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുക.

./scripts/postfixsetup

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

ആകർഷണീയമായത്! കുറച്ച് ദിവസത്തിനുള്ളിൽ, എല്ലാം ശരിയായി ക്രമീകരിച്ചിട്ടുണ്ടെങ്കിൽ സെർവറിൽ നിന്ന് മെയിൽ അയയ്ക്കാൻ നിങ്ങൾക്ക് കഴിയണം.

നിങ്ങളുടെ മെയിൽ സെർവറിനായി നിങ്ങൾ DNS ക്രമീകരിച്ചിട്ടുണ്ടെങ്കിൽ, റെക്കോർഡുകൾ അപ്ഡേറ്റ് ചെയ്യുന്നതിന് 72 മണിക്കൂറിൽ താഴെ സമയമെടുക്കും. ഇത് സാധാരണയായി വളരെ വേഗത്തിലാണ്. ഈ കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങളുടെ സെർവർ പ്രവർത്തിക്കുന്നുണ്ടോയെന്ന് നിങ്ങൾക്ക് പരിശോധിക്കാൻ കഴിയും, നിങ്ങളുടെ ഇമെയിൽ വിതരണം ചെയ്തു:

echo "test" | mail -s "Test Email" youremail@gmail.com

എല്ലാം ശരിയായി പ്രവർത്തിക്കുന്നതായി തോന്നുകയാണെങ്കിൽ, നിങ്ങളുടെ സെർവറിൽ ഇമെയിൽ അയയ്ക്കാൻ നിങ്ങൾക്ക് കഴിയണം. ഇത് പ്രവർത്തിക്കുന്നില്ലെങ്കിൽ, പിശക് എന്തായിരിക്കുമെന്ന് കാണുന്നതിന് ലോഗുകൾ നോക്കാൻ ശ്രമിക്കുക.

tail –lines 150 /var/log/mail.log

ഇത് മെയിലിനെക്കുറിച്ചുള്ള വെർബോസ് വിവരങ്ങൾ നൽകും, അത് സെർവർ അയയ്ക്കുന്നതും ശരിയായി പ്രവർത്തിക്കുന്നുണ്ടോ എന്നതുമാണ്. നിങ്ങളുടെ ഇൻബോക്സിലെ ഇമെയിൽ കാണാനും അത് ഇല്ലെങ്കിൽ, നിങ്ങളുടെ സ്പാം ഫോൾഡർ പരിശോധിക്കുക.

നിങ്ങളുടെ ക്രമീകരണങ്ങളിൽ നിങ്ങളുടെ ക്രമീകരണങ്ങൾ ക്രമീകരിക്കേണ്ടതുണ്ട്. അതിനാൽ നിങ്ങളുടെ ഇമെയിൽ സെർവറിന് നിങ്ങളുടെ ജാങ്കോ അപ്ലിക്കേഷനുമായി സംസാരിക്കാം. നിങ്ങളുടെ ക്രമീകരണങ്ങളിൽ ഈ വരികൾ ചേർക്കുക അല്ലെങ്കിൽ മാറ്റിസ്ഥാപിക്കുക

EMAIL_HOST_USER = 'team' # 'En ലവ് ലമശിൻ.കോം'

പാസ്വേഡ് ലഭിക്കുന്നതിന് ഞങ്ങൾ ഒരു കോൺഫിഗറേഷൻ ഫയൽ ഉപയോഗിക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക. ഫയലിന്റെ തുടക്കത്തിൽ ക്രമീകരണങ്ങളിൽ ഈ ഫയൽ ലോഡുചെയ്യാം.:

# കോൺഫിഗറേഷൻ തുറന്ന് ലോഡ് ചെയ്യുക

നമുക്ക് ഈ ഫയൽ സൃഷ്ടിച്ച് അതിലേക്ക് ഒരു രഹസ്യ കീ ചേർക്കാം, അതുപോലെ തന്നെ മെയിൽ പാസ്വേഡും. ഒരു രഹസ്യ കീ സൃഷ്ടിക്കുന്നതിന്, ഈ കമാൻഡ് ഉപയോഗിക്കുക, അവസാനം നിങ്ങൾ ഇഷ്ടപ്പെടുന്ന ദൈർഘ്യമുള്ള ദൈർഘ്യം ഉപയോഗിക്കുക:

openssl rand -base64 64

ഇപ്പോൾ, Opensl ഉം /etc/config.json ഉം എഡിറ്റുചെയ്യുകയും എഡിറ്റുചെയ്യുകയും ചെയ്യുന്ന വാചകം പകർത്തുക

sudo nano /etc/config.json

രഹസ്യ കീയായി ജനറേറ്റുചെയ്ത താക്കോൽ നിങ്ങളുടെ ഫയലിലേക്ക് ഇനിപ്പറയുന്ന ലൈനുകൾ ചേർക്കുക.

{
	"SECRET_KEY": "XXXXXXXXXXXXXXXXXXXXXXXXXXXXX-generated-using-openssl)",
	"EMAIL_HOST_PASSWORD": "yourpassword"
}

Json ഫോർമാറ്റ് ലളിതവും ഉപയോഗിക്കാൻ എളുപ്പവുമാണ്, മാത്രമല്ല ഞങ്ങളുടെ പ്രോജക്റ്റിൽ ഞങ്ങൾ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്ന മറ്റ് കീകൾ പ്രഖ്യാപിക്കാനും ഞങ്ങളുടെ പ്രോജക്റ്റ് ഡയറക്ടറിയിൽ നിന്ന് അവയെ വേർപെടുത്തുകയും ചെയ്യാം, അതിനാൽ മറ്റ് ഉപയോക്താക്കൾക്ക് അവയ്ക്ക് മാത്രം എഴുതാൻ കഴിയില്ല, അതിനാൽ അവ ഞങ്ങളുടെ പ്രോജക്റ്റ് ഡയറക്ടറിയിൽ മാത്രം വായിക്കാൻ കഴിയില്ല. API കീകൾക്കായി ഇത് പ്രാക്ടീസ് ശുപാർശ ചെയ്യുന്നു, അതിൽ കുറച്ചുകാലത്തിലധികം ഞങ്ങൾ ഇവിടെ ഉപയോഗിക്കും.

എല്ലാം സംരക്ഷിച്ചുവെന്ന് ഉറപ്പാക്കാൻ നിങ്ങളുടെ പ്രോജക്റ്റ് ബാക്കപ്പ് ചെയ്യാനും നിങ്ങൾ മേലിൽ ഒരു സെർവർ വാടകയ്ക്കെടുക്കാൻ ആഗ്രഹിക്കുന്നില്ലെങ്കിലും പിന്നീട് നിങ്ങളുടെ ജോലി വീണ്ടെടുക്കാൻ കഴിയും.

sudo backup

ഇപ്പോൾ, കമാൻഡ് ലൈനിൽ നിന്ന് ഒരെണ്ണം അയയ്ക്കുന്നതിന് നൽകിയ വെബ് സെർവറിൽ നിന്ന് ഒരു HTML ഇമെയിൽ അയയ്ക്കാൻ ശ്രമിക്കുക. നിങ്ങളുടെ ഉപയോക്തൃ ഉദാഹരണം ഷെല്ലിൽ അന്വേഷിക്കുക, അവ ഉപയോക്താവിലേക്ക് ഒരു HTML ഇമെയിൽ അയയ്ക്കുക jjango വഴി ഒരു HTML ഇമെയിൽ അയയ്ക്കുക. നിങ്ങളുടെ പേര്, ഷാർലറ്റ്, നിങ്ങളുടെ ഉപയോക്തൃനാമത്തിലേക്ക്.

python manage.py shell
from django.contrib.auth.models import User
u = User.objects.get(username='Charlotte')
from users.email import send_welcome_email
send_welcome_email(u)
exit()

ആദ്യ കമാൻഡ് പ്രവർത്തിക്കുന്നില്ലെങ്കിൽ, ഉപയോഗിക്കുന്നത് ഉറപ്പാക്കുക

source venv/bin/activate

എല്ലാം ശരിയായി സജ്ജമാക്കിയിട്ടുണ്ടെങ്കിൽ, നിങ്ങളുടെ വെബ് അപ്ലിക്കേഷൻ അയച്ച നിങ്ങളുടെ മെയിൽബോക്സിൽ നിങ്ങൾക്ക് ഇപ്പോൾ സ്വാഗത ഇമെയിൽ ലഭിക്കും. നല്ല ജോലി! നിങ്ങൾ ഒരുപാട് ദൂരം വന്നിരിക്കുന്നു.

ഇതുപോലുള്ള ഒരു പ്രോജക്റ്റിൽ പ്രവർത്തിക്കുമ്പോൾ നിങ്ങൾ എപ്പോഴെങ്കിലും ഒരു പിശകുകളുമായി കഷ്ടപ്പെടുകയാണെങ്കിൽ, ഉത്തരങ്ങൾക്കായി തിരയാനും സഹായം ആവശ്യപ്പെടാനും മടിക്കരുത്. മറ്റ് സെർച്ച് എഞ്ചിനുകളിൽ Google പ്രോഗ്രാമിംഗ് സഹായത്തിനായി തിരയുന്നതിന് മികച്ച വിഭവങ്ങളാണ്. നിങ്ങൾ ലഭിക്കുന്ന പിശകിനായി തിരയുക, മറ്റ് ആളുകൾ എങ്ങനെ പ്രശ്നം പരിഹരിക്കുന്നുവെന്ന് നിങ്ങൾക്ക് കാണാൻ കഴിയും. കൂടാതെ, എന്നെ ബന്ധപ്പെടാൻ നിങ്ങൾക്ക് സ്വാഗതം, നിങ്ങളുടെ അധ്യാപകർ (അധ്യാപകർ, പ്രൊഫസർമാർ, ട്യൂട്ടർമാർ), നിങ്ങൾ അനുഭവിക്കുന്ന പ്രശ്നങ്ങൾക്ക് ലഭ്യമായ പ്രശ്നങ്ങൾ കണ്ടെത്തുന്നതിന് വീണ്ടും അല്ലെങ്കിൽ മറ്റ് ഉറവിടങ്ങൾ അല്ലെങ്കിൽ മറ്റ് ഉറവിടങ്ങൾ. ഇത് എളുപ്പമല്ലെന്ന് ഞാൻ മനസ്സിലാക്കുന്നു, പക്ഷേ നിങ്ങൾ ഈ ദൂരത്തേക്ക് വായിക്കുകയും ഒരു കോഡ് എഴുതുകയും ചെയ്തില്ലെങ്കിലും, ആദ്യം മുതൽ ഒരു വെബ് അപ്ലിക്കേഷൻ നിർമ്മിക്കുന്നതിനെക്കുറിച്ച് നിങ്ങൾ വളരെയധികം പഠിക്കുന്നു. സ്വയം പിന്നിൽ പാറ്റുചെയ്യുക, നിങ്ങൾ ഒരു മികച്ച ജോലി ചെയ്യുന്നു.

ഈ മൂന്നാം പതിപ്പ് വെബ് വികസന ഗൈഡ് വായിക്കാൻ സമയമെടുത്തതിന് നന്ദി. ഭാവിയിലെ പതിപ്പുകളിൽ, പ്രമാണത്തിന്റെ തുടക്കത്തിൽ ചർച്ച ചെയ്ത കൂടുതൽ പ്രധാന ഉദാഹരണങ്ങൾ ഞാൻ ഉൾപ്പെടുത്തും, മാത്രമല്ല സോഫ്റ്റ്വെയറിന്റെയും ഹാർഡ്വെയർ വികസനത്തിന്റെയും ലോകത്തേക്ക് ഞങ്ങൾ കൂടുതൽ ആഴത്തിൽ മുഴങ്ങും. വരാനിരിക്കുന്നവയ്ക്കായി തുടരുക, അവിശ്വസനീയമായ സോഫ്റ്റ്വെയർ എങ്ങനെ നിർമ്മിക്കാമെന്ന് നിങ്ങളെ പഠിപ്പിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. അടുത്ത പതിപ്പിൽ കാണാം!