പപ്പറ്റ് പ്രോഗ്രാമിംഗ് ഭാഷ. പപ്പറ്റ് ഉപയോഗിച്ച് UNIX സിസ്റ്റങ്ങളുടെ കേന്ദ്രീകൃത കോൺഫിഗറേഷൻ. RAL സിൻക്രൊണൈസേഷൻ സൈക്കിൾ

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

ഇത്തരത്തിലുള്ള ഏറ്റവും മികച്ച പരിഹാരങ്ങളിലൊന്നായി പപ്പറ്റ് കണക്കാക്കപ്പെടുന്നു. ഗൂഗിൾ, സിട്രിക്സ്, റെഡ് ഹാറ്റ് തുടങ്ങിയ കമ്പനികളാണ് ഇത് ഉപയോഗിക്കുന്നത്. ഇത് സ്വയം ക്ലയന്റ്-സെർവർ ആപ്ലിക്കേഷൻറൂബി പ്രോഗ്രാമിംഗ് ഭാഷയിൽ എഴുതിയിരിക്കുന്നു, അത് രണ്ട് പതിപ്പുകളായി വിതരണം ചെയ്യുന്നു:

പാവ ഓപ്പൺ സോഴ്സ്- പൂർണ്ണമായും സൌജന്യ പതിപ്പ്
പപ്പറ്റ് എന്റർപ്രൈസ് - 10 സെർവറുകൾ വരെ സൗജന്യമാണ്, തുടർന്ന് ലൈസൻസുകൾ ആവശ്യമാണ്

മിക്ക ആധുനിക വിതരണങ്ങളുടെയും പാക്കേജുകളിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന പപ്പറ്റ് ഓപ്പൺ സോഴ്‌സ് സെർവറും ഏജന്റും ഇൻസ്റ്റാൾ ചെയ്യുന്നത് പരിഗണിക്കാം. അടുത്തതായി നമ്മൾ ഉബുണ്ടു 12.04 കൃത്യമായ പാംഗോലിനിനെക്കുറിച്ച് സംസാരിക്കും.

പപ്പറ്റിന്റെ പിൻഭാഗത്തെ വിളിക്കുന്നു പാവ കളിക്കാരൻ, നമുക്ക് അവിടെ നിന്ന് ഇൻസ്റ്റാളേഷൻ ആരംഭിക്കാം:

:~# apt-get install puppetmaster

ഇപ്പോൾ ക്ലയന്റ്:

:~# apt-get install puppet

ക്ലയന്റ് കോൺഫിഗറേഷൻ ഫയലിൽ /etc/puppet/puppet.confഇനിപ്പറയുന്ന വിഭാഗം ചേർത്തുകൊണ്ട് നിങ്ങൾ സെർവറിനെക്കുറിച്ച് സംസാരിക്കേണ്ടതുണ്ട്:

Server=puppet.local report=true pluginsync=false

പ്രാരംഭ ഘട്ടത്തിൽ, pluginsync ഓഫ് ചെയ്യുന്നതാണ് നല്ലത്.

പപ്പറ്റ് ക്ലയന്റ് പ്രവർത്തിപ്പിക്കാം, അങ്ങനെ അത് ഒരു സർട്ടിഫിക്കറ്റിനായി ഒരു അഭ്യർത്ഥന സൃഷ്ടിക്കുന്നു:

:~# puppetd --verbose --test info: linux.local വിവരങ്ങൾക്കായി ഒരു പുതിയ SSL കീ സൃഷ്‌ടിക്കുന്നു: ca വിവരങ്ങൾക്കായി കാഷിംഗ് സർട്ടിഫിക്കറ്റ്: linux. ലോക്കൽ വിവരത്തിനായി ഒരു പുതിയ SSL സർട്ടിഫിക്കറ്റ് അഭ്യർത്ഥന സൃഷ്ടിക്കുന്നു: സർട്ടിഫിക്കറ്റ് അഭ്യർത്ഥന ഫിംഗർപ്രിന്റ് (md5): E5: EA:AC:5B:22:9A:BA:42:B8:A1:63:9E:1F:1F:23:51 പുറത്തുകടക്കുന്നു; സർട്ടിഫിക്കറ്റുകളൊന്നും കണ്ടെത്തിയില്ല കൂടാതെ വെയ്റ്റ്ഫോർസെർട്ട് പ്രവർത്തനരഹിതമാക്കിയിരിക്കുന്നു

സെർവറിൽ, സർട്ടിഫിക്കറ്റ് അഭ്യർത്ഥന ലഭിച്ചിട്ടുണ്ടോയെന്ന് നിങ്ങൾ പരിശോധിക്കേണ്ടതുണ്ട്, അങ്ങനെയെങ്കിൽ, ഒരു സർട്ടിഫിക്കറ്റ് നൽകുക:

:~# puppetca --list "linux.local" (E5:EA:AC:5B:22:9A:BA:42:B8:A1:63:9E:1F:1F:23:51) :~# puppetca - -sign linux.local അറിയിപ്പ്: linux.local അറിയിപ്പിനായി ഒപ്പിട്ട സർട്ടിഫിക്കറ്റ് അഭ്യർത്ഥന: "/var/lib/puppet/ssl/ca/requests/linux.local.pem" എന്നതിലെ പപ്പറ്റ്::SSL::CertificateRequest linux.local ഫയൽ നീക്കംചെയ്യുന്നു

ക്ലയന്റിൽ മുമ്പത്തെ ഘട്ടം ആവർത്തിക്കുക:

:~# puppetd --verbose --test info: linux.local വിവരത്തിനായുള്ള കാഷിംഗ് സർട്ടിഫിക്കറ്റ്: പ്ലഗിൻ വിവരങ്ങൾ വീണ്ടെടുക്കുന്നു: CA വിവരത്തിനുള്ള സർട്ടിഫിക്കറ്റ്_revocation_list കാഷിംഗ്: linux.local വിവരത്തിനുള്ള കാഷിംഗ് കാറ്റലോഗ്: കോൺഫിഗറേഷൻ പതിപ്പ് പ്രയോഗിക്കുന്നു "1356278451" സ്റ്റേറ്റ് ഫയൽ സൃഷ്ടിക്കുന്നു വിവരം: var/lib/puppet/state/state.yaml അറിയിപ്പ്: കാറ്റലോഗ് റൺ 0.02 സെക്കൻഡിൽ പൂർത്തിയാക്കി

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

മൊഡ്യൂളുകൾക്കായി പാവ എവിടെയാണ് തിരയുന്നതെന്ന് നമുക്ക് പരിശോധിക്കാം:

:~# puppet apply --configprint modulepath /etc/puppet/modules:/usr/share/puppet/modules

നിങ്ങളുടെ മൊഡ്യൂളിനായി ഡയറക്ടറികൾ സൃഷ്ടിക്കുക

:~# cd /etc/puppet/modules :~# mkdir ഹോസ്റ്റുകൾ; സിഡി ഹോസ്റ്റുകൾ; mkdir പ്രകടമാകുന്നു; സിഡി പ്രകടമാകുന്നു

പ്രധാന മൊഡ്യൂൾ ഫയൽ എന്നും അറിയപ്പെടുന്ന ആദ്യത്തെ മാനിഫെസ്റ്റ് വിളിക്കപ്പെടണം init.pp

ക്ലാസ് ഹോസ്റ്റുകൾ ( # puppet.local host ( "puppet.local": ഉറപ്പാക്കുക => "നിലവിൽ", ലക്ഷ്യം => "/etc/hosts", ip => "192.168.0.1", host_aliases => "puppet", ) # linux.local host ( "linux.local": ഉറപ്പാക്കുക => "നിലവിൽ", ലക്ഷ്യം => "/etc/hosts", ip => "192.168.0.2", host_aliases => "linux", ) )

സ്ഥിരസ്ഥിതിയായി, പപ്പറ്റ് ഒരു ഫയലിനായി തിരയുന്നു /etc/puppet/manifests/site.ppകോൺഫിഗറേഷൻ ലോഡ് ചെയ്യാൻ, നമുക്ക് അതിനെ ഇനിപ്പറയുന്ന ഫോമിലേക്ക് കൊണ്ടുവരാം:

നോഡ് ഡിഫോൾട്ട് (ഹോസ്റ്റുകൾ ഉൾപ്പെടുന്നു)

സെർവറിലെ മാനിഫെസ്റ്റ് ഞങ്ങൾ പരിശോധിക്കുന്നു:

:~# puppet apply --verbose /etc/puppet/manifests/site.pp വിവരം: കോൺഫിഗറേഷൻ പതിപ്പ് "1356281036" പ്രയോഗിക്കുന്നു അറിയിപ്പ്: /സ്റ്റേജ്//ഹോസ്റ്റ്/ഉറപ്പു: സൃഷ്ടിച്ച വിവരം: ഫയൽബക്കറ്റ് ചേർക്കുന്നു (md5)അറിയിപ്പ്: /സ്റ്റേജ്// ഹോസ്റ്റ്/ഉറപ്പുവരുത്തുക: സൃഷ്ടിച്ച അറിയിപ്പ്: 0.03 സെക്കൻഡിൽ കാറ്റലോഗ് റൺ പൂർത്തിയാക്കി

ക്ലയന്റിനെക്കുറിച്ച്:

:~# ll /etc/hosts rw-r--r-- 1 റൂട്ട് റൂട്ട് 290 ഡിസംബർ 16 19:10 /etc/hosts :~# puppetd --verbose --test info: linux.caching catalog.local info: പ്രയോഗിക്കുന്നു കോൺഫിഗറേഷൻ പതിപ്പ് "1356283380" വിവരം: ഫയൽബക്കറ്റ് ചേർക്കുന്നു (md5)അറിയിപ്പ്: /സ്റ്റേജ്/ഹോസ്റ്റുകൾ/ഹോസ്റ്റ്/ഉറപ്പു: സൃഷ്ടിച്ച അറിയിപ്പ്: /സ്റ്റേജ്/ഹോസ്റ്റുകൾ/ഹോസ്റ്റ്/ഉറപ്പു: സൃഷ്ടിച്ച അറിയിപ്പ്: 0.04 സെക്കൻഡിനുള്ളിൽ പൂർത്തിയാക്കിയ കാറ്റലോഗ് റൺ :~# ll /etc /hosts -rw-r--r-- 1 റൂട്ട് റൂട്ട് 551 ഡിസംബർ 23 20:43 /etc/hosts

എല്ലാം പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കിയ ശേഷം, സേവനം ആരംഭിക്കാൻ ഞങ്ങൾ അനുവദിക്കുന്നു /etc/default/puppetമാറ്റം:

# ബൂട്ടിൽ പപ്പറ്റ് തുടങ്ങണോ? START=അതെ

സേവനം ആരംഭിക്കുന്നു

:~# സേവന പാവ തുടക്കം

കോൺഫിഗറേഷൻ മാറ്റങ്ങൾക്കായി ഓരോ 30 മിനിറ്റിലും പപ്പറ്റ് പപ്പറ്റ്മാസ്റ്റർ സെർവറിൽ വോട്ടെടുപ്പ് നടത്തും, ആവശ്യമെങ്കിൽ അതിനനുസരിച്ച് സിസ്റ്റം ക്രമീകരിക്കും.

കൂടുതൽ ഫലപ്രദമായ ഉപയോഗംമൊഡ്യൂളുകളും മാനിഫെസ്റ്റുകളും എങ്ങനെ നിർമ്മിക്കപ്പെടുന്നുവെന്ന് പപ്പറ്റ് മനസ്സിലാക്കേണ്ടതുണ്ട്. ഉബുണ്ടു 14.04 സെർവറിൽ ഒരു LAMP സ്റ്റാക്ക് സജ്ജീകരിക്കുന്നതിലൂടെ ഈ പപ്പറ്റ് ഘടകങ്ങൾ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് ഈ ട്യൂട്ടോറിയൽ നിങ്ങളെ അറിയിക്കും.

ആവശ്യകതകൾ

പപ്പറ്റ് (മാസ്റ്ററും ഏജന്റും) ഇൻസ്റ്റാൾ ചെയ്യുന്നു. ഇതിനെക്കുറിച്ച് കൂടുതൽ -.
ഒരെണ്ണമെങ്കിലും സൃഷ്ടിക്കാനുള്ള സാധ്യത വെർച്വൽ സെർവർപപ്പറ്റ് ഏജന്റ് നോഡിന്റെ സേവനത്തിനായി ഉബുണ്ടു 14.04.

പപ്പറ്റ് കോഡ് അടിസ്ഥാനങ്ങൾ

വിഭവങ്ങൾ

പപ്പറ്റ് കോഡ് പ്രധാനമായും വിഭവങ്ങൾ ഉൾക്കൊള്ളുന്നു. ഒരു റിസോഴ്‌സ് എന്നത് സിസ്റ്റത്തിന്റെ അവസ്ഥയെ വിവരിക്കുകയും അതിന് ആവശ്യമായ മാറ്റങ്ങൾ നിർണ്ണയിക്കുകയും ചെയ്യുന്ന ഒരു കോഡാണ്. ഉദാഹരണത്തിന്:

ഉപയോക്താവ് ("മിച്ചൽ":
=> ഉണ്ടെന്ന് ഉറപ്പാക്കുക,
uid => "1000",
gid => "1000",
ഷെൽ => "/ബിൻ/ബാഷ്",
വീട് => "/home/mitchell"
}

വിഭവ പ്രഖ്യാപനത്തിന് ഇനിപ്പറയുന്ന ഫോർമാറ്റ് ഉണ്ട്:

resource_type("resource_name"
ആട്രിബ്യൂട്ട് => മൂല്യം
...
}

എല്ലാ പപ്പറ്റ് റിസോഴ്സ് തരങ്ങളും കാണുന്നതിന്, കമാൻഡ് നൽകുക:

പാവ വിഭവങ്ങൾ --തരം

ഈ ഗൈഡിൽ റിസോഴ്സ് തരങ്ങളെക്കുറിച്ച് കൂടുതലറിയാൻ നിങ്ങൾ പഠിക്കും.

മാനിഫെസ്റ്റോകൾ

ഒരു മാനിഫെസ്റ്റ് ഒരു ഓർക്കസ്ട്രേഷൻ സ്ക്രിപ്റ്റാണ്. .pp വിപുലീകരണമുള്ള പപ്പറ്റ് പ്രോഗ്രാമുകളെ മാനിഫെസ്റ്റുകൾ എന്ന് വിളിക്കുന്നു. ഡിഫോൾട്ട് പപ്പറ്റ് മാനിഫെസ്റ്റ് /etc/puppet/manifests/site.pp ആണ്.

ക്ലാസുകൾ

ഏതൊരു സാധാരണ പ്രോഗ്രാമിംഗ് ഭാഷയിലെയും പോലെ, ഓർക്കസ്ട്രേഷന്റെ ഭാഗങ്ങൾ സംഘടിപ്പിക്കുന്നതിനും പുനരുപയോഗിക്കുന്നതിനും ക്ലാസുകൾ ഉത്തരവാദികളാണ്.

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

ക്ലാസ് നിർവചനത്തിന് ഇനിപ്പറയുന്ന ഫോർമാറ്റ് ഉണ്ട്:

ക്ലാസ് ഉദാഹരണം_ക്ലാസ്(
...
കോഡ്
...
}

ഈ കോഡ് ഉദാഹരണ_ക്ലാസ് ക്ലാസ് നിർവചിക്കുന്നു. പപ്പറ്റ് കോഡ് ചുരുണ്ട ബ്രേസുകളിലായിരിക്കും.

ഒരു പ്രത്യേക ക്ലാസ് എന്ന് വിളിക്കപ്പെടുന്ന കോഡിലെ സ്ഥലമാണ് ക്ലാസ് ഡിക്ലറേഷൻ. ഒരു ക്ലാസ് ഡിക്ലറേഷൻ ഉപയോഗിച്ച്, പപ്പറ്റ് അതിന്റെ കോഡ് പ്രോസസ്സ് ചെയ്യുന്നു.

ക്ലാസ് പ്രഖ്യാപനം സാധാരണവും റിസോഴ്സ് തരവും ആകാം.

ഉൾപ്പെടുത്തിയ കീവേഡ് ഉപയോഗിച്ച് കോഡിലേക്ക് ഒരു സാധാരണ ക്ലാസ് ഡിക്ലറേഷൻ ചേർക്കുന്നു.

example_class ഉൾപ്പെടുത്തുക

ഒരു റിസോഴ്സ് തരമായി പ്രഖ്യാപിക്കുമ്പോൾ, ക്ലാസ് റിസോഴ്സ് ഫോർമാറ്റിൽ പ്രഖ്യാപിക്കപ്പെടും:

ക്ലാസ്("ഉദാഹരണം_ക്ലാസ്":)

ക്ലാസ് ആട്രിബ്യൂട്ടുകളുടെ ഡിഫോൾട്ട് മൂല്യങ്ങളെ മറികടക്കുന്ന ക്ലാസ് പാരാമീറ്ററുകൾ നിങ്ങളുടെ കോഡിലേക്ക് ചേർക്കാൻ ഈ പ്രഖ്യാപനം നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്:

നോഡ് "ഹോസ്റ്റ്2" (
ക്ലാസ് ("അപ്പാച്ചെ": ) # അപ്പാച്ചെ മൊഡ്യൂൾ ഉപയോഗിക്കുക
apache::vhost ("example.com": # vhost റിസോഴ്സ് നിർവചിക്കുക
പോർട്ട് => "80",
docroot => "/var/www/html"
}
}

മൊഡ്യൂളുകൾ

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

പപ്പറ്റ് മൊഡ്യൂളുകൾ /etc/puppet/modules ഡയറക്ടറിയിൽ സൂക്ഷിക്കുന്നു.

മാനിഫെസ്റ്റോ എഴുതുന്നു

ഒരു ഉബുണ്ടു സെർവറിൽ ഒരു LAMP സ്റ്റാക്ക് ഇൻസ്റ്റാൾ ചെയ്യുന്നതിന്റെ ഉദാഹരണം ഉപയോഗിച്ച് നിങ്ങൾക്ക് പപ്പറ്റ് മാനിഫെസ്റ്റുകളും മൊഡ്യൂളുകളും ക്ലാസുകളും എഴുതാൻ പരിശീലിക്കാം (ഫലം ആയിരിക്കും ).

അങ്ങനെ ഓർക്കസ്ട്രേഷൻ ചെയ്യാൻ ഉബുണ്ടു സെർവറുകൾ 14.04 അതിൽ LAMP സ്റ്റാക്ക് ഇൻസ്റ്റാൾ ചെയ്യുക, ഇനിപ്പറയുന്ന പ്രവർത്തനങ്ങൾക്ക് നിങ്ങൾക്ക് ഉറവിടങ്ങൾ ആവശ്യമാണ്:

apache2 പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്യുന്നു.
apache2 സേവനം ആരംഭിക്കുന്നു.
MySQL സെർവർ പാക്കേജ്, mysql-server ഇൻസ്റ്റാൾ ചെയ്യുന്നു.
mysql സേവനം ആരംഭിക്കുന്നു.
php5 പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്യുന്നു
ഒരു PHP ടെസ്റ്റ് സ്ക്രിപ്റ്റ് സൃഷ്ടിക്കുന്നു, info.php.
ഓരോ പാക്കേജും ഇൻസ്റ്റാൾ ചെയ്യുന്നതിന് മുമ്പ് apt ഇൻഡക്സ് അപ്ഡേറ്റ് ചെയ്യുന്നു.

അത്തരമൊരു LAMP സ്റ്റാക്ക് സജ്ജീകരണം നേടുന്നതിന് ഉപയോഗിക്കാവുന്ന പപ്പറ്റ് കോഡിന്റെ മൂന്ന് ഉദാഹരണങ്ങൾ നിങ്ങൾക്ക് ചുവടെ കാണാം.

ഒരു ഫയലിൽ അടിസ്ഥാന മാനിഫെസ്റ്റുകൾ എങ്ങനെ എഴുതാമെന്ന് ആദ്യ ഉദാഹരണം നിങ്ങളെ പഠിപ്പിക്കും. മുമ്പ് എഴുതിയ മാനിഫെസ്റ്റുകളെ അടിസ്ഥാനമാക്കി ഒരു ക്ലാസും മൊഡ്യൂളും കൂട്ടിച്ചേർക്കാനും ഉപയോഗിക്കാനും രണ്ടാമത്തെ ഉദാഹരണം നിങ്ങളെ സഹായിക്കും. ഒരു LAMP സ്റ്റാക്ക് ഇൻസ്റ്റാൾ ചെയ്യുന്നതിന് മുൻകൂട്ടി നിർമ്മിച്ച പൊതു മൊഡ്യൂളുകൾ എങ്ങനെ ഉപയോഗിക്കാമെന്ന് മൂന്നാമത്തെ ഉദാഹരണം നിങ്ങളെ കാണിക്കും.

കുറിപ്പ്: ടെസ്റ്റിംഗിനായി ഒരു പുതിയ വെർച്വൽ സെർവർ ഉപയോഗിക്കുന്നതാണ് നല്ലത്.

ഉദാഹരണം 1: ഒരു മാനിഫെസ്റ്റ് ഉപയോഗിച്ച് LAMP ഇൻസ്റ്റാൾ ചെയ്യുന്നു

പപ്പറ്റ് മാനിഫെസ്റ്റ് ഏജന്റ് നോഡിൽ എഴുതുകയും പിന്നീട് പപ്പറ്റ് പ്രയോഗിക്കുക കമാൻഡ് ഉപയോഗിച്ച് എക്സിക്യൂട്ട് ചെയ്യുകയും ചെയ്യാം (ഇത് ചെയ്യുന്നതിന് നിങ്ങൾക്ക് ഒരു മാസ്റ്ററും ഏജന്റ് സജ്ജീകരണവും ആവശ്യമില്ല).

ഈ വിഭാഗത്തിൽ, ഈ തരത്തിലുള്ള റിസോഴ്സ് ഡിക്ലറേഷനുകൾ ഉപയോഗിക്കുന്ന മാനിഫെസ്റ്റുകൾ എഴുതാൻ നിങ്ങൾ പഠിക്കും:

exec: കമാൻഡുകൾ എക്സിക്യൂട്ട് ചെയ്യുക.
പാക്കേജ്: പാക്കേജുകൾ ഇൻസ്റ്റാൾ ചെയ്യുക.
സേവനം: സേവന മാനേജ്മെന്റ്.
ഫയൽ: ഫയൽ മാനേജ്മെന്റ്.

ഒരു മാനിഫെസ്റ്റ് സൃഷ്ടിക്കുന്നു

ഒരു പുതിയ മാനിഫെസ്റ്റ് സൃഷ്‌ടിക്കുക:

sudo vi /etc/puppet/manifests/lamp.pp

ആവശ്യമായ ഉറവിടങ്ങൾ പ്രഖ്യാപിക്കാൻ ഇനിപ്പറയുന്ന കോഡ് അതിൽ ചേർക്കുക.

# "apt-get update" കമാൻഡ് പ്രവർത്തിപ്പിക്കുക
exec("apt-update": # resource exec "apt-update"
കമാൻഡ് => "/usr/bin/apt-get update" # കമാൻഡ് ഈ റിസോഴ്സ് പ്രവർത്തിക്കും
}
# apache2 പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്യുക
പാക്കേജ് ("apache2":
ആവശ്യമാണ് => Exec["apt-update"], # പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്യുന്നതിന് മുമ്പ് "apt-update" അഭ്യർത്ഥിക്കുക
=> ഇൻസ്റ്റാൾ ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കുക,
}
# apache2 സേവനം ആരംഭിക്കുക
സേവനം("apache2":
=> പ്രവർത്തിക്കുന്നത് ഉറപ്പാക്കുക,
}
# mysql-server ഇൻസ്റ്റാൾ ചെയ്യുക
പാക്കേജ് ("mysql-server":
ആവശ്യമാണ് => Exec["apt-update"], # വീണ്ടും ഇൻസ്റ്റാൾ ചെയ്തുകൊണ്ട് "apt-update" അഭ്യർത്ഥിക്കുന്നു
=> ഇൻസ്റ്റാൾ ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കുക,
}
# mysql സേവനം ആരംഭിക്കുക
സേവനം("mysql":
=> പ്രവർത്തിക്കുന്നത് ഉറപ്പാക്കുക,
}
# php5 പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്യുക
പാക്കേജ് ("php5":
ആവശ്യമാണ് => Exec["apt-update"], # ഇൻസ്റ്റാളേഷന് മുമ്പ് "apt-update" അഭ്യർത്ഥിക്കുക
=> ഇൻസ്റ്റാൾ ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കുക,
}
# info.php സേവനം ആരംഭിക്കുക
ഫയൽ("/var/www/html/info.php":
=> ഫയൽ ഉറപ്പാക്കുക,
ഉള്ളടക്കം => "", # phpinfo കോഡ്
ആവശ്യമാണ് => പാക്കേജ്["apache2"], # "apache2" പാക്കേജിനുള്ള അഭ്യർത്ഥന
}

ഒരു മാനിഫെസ്റ്റ് പ്രയോഗിക്കുന്നു

പുതിയ മാനിഫെസ്റ്റ് ഉപയോഗിക്കുന്നതിന്, കമാൻഡ് നൽകുക:

sudo puppet apply --test

പരിസ്ഥിതിയുടെ അവസ്ഥയിലെ എല്ലാ മാറ്റങ്ങളും പ്രദർശിപ്പിക്കുന്ന ഒരു വലിയ ഫലം ഇത് പ്രദർശിപ്പിക്കും. ഔട്ട്പുട്ടിൽ പിശകുകളൊന്നും ഇല്ലെങ്കിൽ, നിങ്ങൾക്ക് നിങ്ങളുടെ ബാഹ്യ IP വിലാസം തുറക്കാൻ കഴിയും അല്ലെങ്കിൽ ഡൊമെയ്ൻ നാമംബ്രൗസറിൽ. സ്റ്റാക്ക് വിവരങ്ങളുള്ള ഒരു PHP ടെസ്റ്റ് പേജ് സ്ക്രീനിൽ ദൃശ്യമാകും. ഇതിനർത്ഥം അപ്പാച്ചെയും പിഎച്ച്പിയും പ്രവർത്തിക്കുന്നു എന്നാണ്.

ഇപ്പോൾ LAMP സ്റ്റാക്ക് പപ്പറ്റ് ഉപയോഗിച്ച് സെർവറിൽ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ട്.

ഇത് ഒരു ഏജന്റിൽ എക്സിക്യൂട്ട് ചെയ്യാൻ കഴിയുന്നതിനാൽ വളരെ ലളിതമായ ഒരു പ്രകടനമാണ്. നിങ്ങൾക്ക് ഒരു പപ്പറ്റ് മാസ്റ്റർ ഇല്ലെങ്കിൽ, മറ്റ് ഏജന്റ് നോഡുകൾക്ക് ഈ മാനിഫെസ്റ്റ് ഉപയോഗിക്കാൻ കഴിയില്ല.

ഓരോ 30 മിനിറ്റിലും സെർവർ നില മാറുന്നുണ്ടോയെന്ന് പപ്പറ്റ് മാസ്റ്റർ സെർവർ പരിശോധിക്കുന്നു.

ഉദാഹരണം 2: ഒരു മൊഡ്യൂൾ ഉപയോഗിച്ച് ഒരു LAMP സ്റ്റാക്ക് ഇൻസ്റ്റാൾ ചെയ്യുന്നു

ഇപ്പോൾ നിങ്ങൾ മുമ്പത്തെ വിഭാഗത്തിൽ എഴുതിയ LAMP മാനിഫെസ്റ്റിനെ അടിസ്ഥാനമാക്കി ഒരു ലളിതമായ മൊഡ്യൂൾ സൃഷ്ടിക്കാൻ ശ്രമിക്കുക.

ഒരു മൊഡ്യൂൾ സൃഷ്ടിക്കാൻ, മൊഡ്യൂൾ ഡയറക്ടറിയിൽ സൃഷ്ടിക്കുക പുതിയ കാറ്റലോഗ്(അതിന്റെ പേര് മൊഡ്യൂളിന്റെ പേരുമായി പൊരുത്തപ്പെടണം). ഈ ഡയറക്ടറിയിൽ ഒരു മാനിഫെസ്റ്റ് ഡയറക്‌ടറിയും init.pp ഫയലും അടങ്ങിയിരിക്കണം. init.pp ഫയൽ പപ്പറ്റ് ക്ലാസ് വ്യക്തമാക്കുന്നു (അതിന്റെ പേരും മൊഡ്യൂളിന്റെ പേരുമായി പൊരുത്തപ്പെടണം).

ഒരു മൊഡ്യൂൾ സൃഷ്ടിക്കുന്നു

പപ്പറ്റ് മാസ്റ്റർ സെർവറിലേക്ക് പോയി മൊഡ്യൂളിനായി ഒരു ഡയറക്ടറി ഘടന സൃഷ്ടിക്കുക:

cd /etc/puppet/modules
sudo mkdir -p വിളക്ക്/പ്രകടനങ്ങൾ

എഡിറ്ററിൽ init.pp ഫയൽ സൃഷ്ടിച്ച് തുറക്കുക:

sudo vi lamp/manifests/init.pp

ഫയലിലേക്ക് ലാമ്പ് ക്ലാസ് തിരുകുക:

ക്ലാസ് വിളക്ക് (
}

സെക്ഷൻ 1-ൽ നിന്ന് മാനിഫെസ്റ്റിന്റെ ഉള്ളടക്കങ്ങൾ പകർത്തി ലാമ്പ് ക്ലാസ് ബ്ലോക്കിലേക്ക് ഒട്ടിക്കുക. നിങ്ങൾക്ക് ഇപ്പോൾ ഒരു വിളക്ക് ക്ലാസ് നിർവചനമുണ്ട്. മറ്റ് മാനിഫെസ്റ്റുകൾക്ക് ഈ ക്ലാസ് ഒരു മൊഡ്യൂളായി ഉപയോഗിക്കാൻ കഴിയും.

ഫയൽ സംരക്ഷിച്ച് അടയ്ക്കുക.

പ്രധാന മാനിഫെസ്റ്റിൽ ഒരു മൊഡ്യൂൾ ഉപയോഗിക്കുന്നു

ഇപ്പോൾ നിങ്ങൾക്ക് പ്രധാന മാനിഫെസ്റ്റ് കോൺഫിഗർ ചെയ്യാനും സെർവറിൽ LAMP സ്റ്റാക്ക് ഇൻസ്റ്റാൾ ചെയ്യാൻ ലാമ്പ് മൊഡ്യൂൾ ഉപയോഗിക്കാനും കഴിയും.

പപ്പറ്റ് മാസ്റ്റർ സെർവറിൽ, ഇനിപ്പറയുന്ന ഫയൽ എഡിറ്റ് ചെയ്യുക:

sudo vi /etc/puppet/manifests/site.pp

മിക്കവാറും ഓണാണ് ഈ നിമിഷംഫയൽ ശൂന്യമാണ്. അതിൽ ഇനിപ്പറയുന്ന വരികൾ ചേർക്കുക:

നോഡ് ഡിഫോൾട്ട് ( )
നോഡ് "വിളക്ക്-1" (
}

കുറിപ്പ്: ലാമ്പ്-1 മാറ്റി പകരം സ്റ്റാക്ക് ഇൻസ്റ്റാൾ ചെയ്യേണ്ട നിങ്ങളുടെ പപ്പറ്റ് ഏജന്റിന്റെ ഹോസ്റ്റ്നാമം നൽകുക.

ചില നോഡുകൾക്ക് മാത്രം ബാധകമാകുന്ന പപ്പറ്റ് കോഡ് വ്യക്തമാക്കാൻ നോഡ് ബ്ലോക്ക് നിങ്ങളെ അനുവദിക്കുന്നു.

ഒരു വ്യക്തിഗത ബ്ലോക്ക് ഇല്ലാത്ത എല്ലാ ഏജന്റ് നോഡുകൾക്കും ഡിഫോൾട്ട് ബ്ലോക്ക് ബാധകമാണ് (അത് ശൂന്യമായി വിടുക). ലാമ്പ്-1 ഏജന്റ് നോഡിലേക്ക് ലാമ്പ്-1 ബ്ലോക്ക് പ്രയോഗിക്കും.

ഈ ബ്ലോക്കിലേക്ക് ചേർക്കുക അടുത്ത വരി, ഇത് വിളക്ക് മൊഡ്യൂൾ ഉപയോഗിക്കുന്നു:

ഫയൽ സംരക്ഷിച്ച് അടയ്ക്കുക.

ഇപ്പോൾ പപ്പറ്റ് ഏജന്റ് നോഡിന് മാസ്റ്റർ സെർവറിൽ നിന്ന് ക്രമീകരണങ്ങൾ ഡൗൺലോഡ് ചെയ്യാനും LAMP സ്റ്റാക്ക് ഇൻസ്റ്റാൾ ചെയ്യാനും കഴിയും. നിങ്ങൾക്ക് ഇപ്പോൾ മാറ്റങ്ങൾ വരുത്തണമെങ്കിൽ, ഏജന്റിൽ കമാൻഡ് പ്രവർത്തിപ്പിക്കുക:

സുഡോ പപ്പറ്റ് ഏജന്റ് --ടെസ്റ്റ്

മൊഡ്യൂളുകളാണ് ഏറ്റവും സൗകര്യപ്രദമായ മാർഗം പുനരുപയോഗംപാവ കോഡ്. കൂടാതെ, നിങ്ങളുടെ കോഡ് യുക്തിസഹമായി ക്രമീകരിക്കാൻ മൊഡ്യൂളുകൾ നിങ്ങളെ സഹായിക്കുന്നു.

ഉദാഹരണം 3: പൊതു മൊഡ്യൂളുകൾ ഉപയോഗിച്ച് LAMP ഇൻസ്റ്റാൾ ചെയ്യുന്നു

MySQL മൊഡ്യൂളും സമാനമായ രീതിയിൽ ഉപയോഗിക്കുന്നു. നോഡ് ബ്ലോക്കിലേക്ക് ഇനിപ്പറയുന്ന വരികൾ ചേർക്കുക:

ക്ലാസ്("mysql::server":
root_password => "പാസ്‌വേഡ്",
}

നിങ്ങൾക്ക് MySQL മൊഡ്യൂൾ പാരാമീറ്ററുകളും കൈമാറാം.

ആവശ്യമുള്ള സ്ഥലത്തേക്ക് info.php പകർത്തുന്ന ഒരു ഉറവിടം ചേർക്കുക. ഉറവിട പാരാമീറ്റർ ഉപയോഗിക്കുക. നോഡ് ബ്ലോക്കിലേക്ക് ഇനിപ്പറയുന്ന വരികൾ ചേർക്കുക:

ഫയൽ("info.php": # റിസോഴ്സ് ഫയലിന്റെ പേര്
പാത്ത് => "/var/www/html/info.php", # ലക്ഷ്യ പാത
=> ഫയൽ ഉറപ്പാക്കുക,
ആവശ്യമാണ് => ക്ലാസ്["അപ്പാച്ചെ"], ഉപയോഗിക്കുന്നതിന് # അപ്പാച്ചെ ക്ലാസ്
ഉറവിടം => "puppet:///modules/apache/info.php", # ലൊക്കേഷൻ ഫയൽ പകർത്താൻ
}

ഈ ക്ലാസ് ഡിക്ലറേഷൻ ഉള്ളടക്കത്തിന് പകരം ഉറവിട പാരാമീറ്റർ ഉപയോഗിക്കുന്നു. ഈ ഓപ്ഷൻ ഫയലിന്റെ ഉള്ളടക്കം മാത്രമല്ല, അത് പകർത്തുകയും ചെയ്യുന്നു.

പപ്പറ്റ് puppet:///modules/apache/info.php എന്ന ഫയൽ /etc/puppet/modules/apache/files/info.php എന്നതിലേക്ക് പകർത്തും.

ഫയൽ സംരക്ഷിച്ച് അടയ്ക്കുക.

ഒരു info.php ഫയൽ സൃഷ്ടിക്കുക.

sudo sh -c "echo""> /etc/puppet/modules/apache/files/info.php"

ഇപ്പോൾ പപ്പറ്റ് ഏജന്റ് നോഡിന് മാസ്റ്റർ സെർവറിൽ നിന്ന് ക്രമീകരണങ്ങൾ ഡൗൺലോഡ് ചെയ്യാനും LAMP സ്റ്റാക്ക് ഇൻസ്റ്റാൾ ചെയ്യാനും കഴിയും. നിങ്ങൾക്ക് ഇപ്പോൾ ഏജന്റ് പരിതസ്ഥിതിയിൽ മാറ്റങ്ങൾ വരുത്തണമെങ്കിൽ, ഈ നോഡിൽ കമാൻഡ് പ്രവർത്തിപ്പിക്കുക:

സുഡോ പപ്പറ്റ് ഏജന്റ് --ടെസ്റ്റ്

ഈ കമാൻഡ് നിലവിലെ നോഡിനായുള്ള എല്ലാ അപ്‌ഡേറ്റുകളും ഡൗൺലോഡ് ചെയ്യുകയും അതിൽ സ്റ്റാക്ക് ഇൻസ്റ്റാൾ ചെയ്യുകയും ചെയ്യും. Apache, PHP എന്നിവ പ്രവർത്തിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കാൻ, ഒരു ബ്രൗസറിൽ നോഡിന്റെ IP വിലാസമോ ഡൊമെയ്‌നോ തുറക്കുക:

http://lamp_1_public_IP/info.php

ഉപസംഹാരം

നിങ്ങൾക്ക് ഇപ്പോൾ പപ്പറ്റ് മൊഡ്യൂളുകളിലും മാനിഫെസ്റ്റുകളിലും പ്രവർത്തിക്കാനുള്ള അടിസ്ഥാന അറിവുണ്ട്. ഒരു ലളിതമായ മാനിഫെസ്റ്റ് സൃഷ്‌ടിച്ച് സ്വയം മൊഡ്യൂൾ ചെയ്യാൻ ശ്രമിക്കുക.

ആപ്ലിക്കേഷൻ കോൺഫിഗറേഷൻ ഫയലുകൾ കൈകാര്യം ചെയ്യുന്നതിന് പപ്പറ്റ് മികച്ചതാണ്.

ടാഗുകൾ:,
Luke Kanies പോസ്റ്റ് ചെയ്തത്
പ്രസിദ്ധീകരിച്ച തീയതി: മെയ് 2, 2012
പരിഭാഷ: എ പാനിൻ
വിവർത്തന തീയതി: ഓഗസ്റ്റ് 27, 2013

18.1 ആമുഖം

റൂബി പ്രോഗ്രാമിംഗ് ഭാഷ ഉപയോഗിച്ച് വികസിപ്പിച്ചെടുത്ത ഒരു ഐടി ഇൻഫ്രാസ്ട്രക്ചർ മാനേജ്‌മെന്റ് ടൂളാണ് പപ്പറ്റ്, കൂടാതെ Google, Twitter, New York Stock Exchange എന്നിവയ്‌ക്കും മറ്റ് നിരവധി ഓർഗനൈസേഷനുകൾക്കുമായി ഡാറ്റാ സെന്റർ മെയിന്റനൻസും സെർവർ മാനേജ്‌മെന്റും ഓട്ടോമേറ്റ് ചെയ്യാൻ ഉപയോഗിക്കുന്നു. പദ്ധതിയുടെ വികസനം പ്രധാനമായും പിന്തുണയ്ക്കുന്നത് പപ്പറ്റ് ലാബ്സ് ഓർഗനൈസേഷനാണ്, അത് അതിന്റെ വികസനത്തിന് അടിത്തറയിട്ടു. പപ്പറ്റിന് 2 മുതൽ 50,000 സെർവറുകൾ വരെ എവിടെയും നിയന്ത്രിക്കാനാകും, കൂടാതെ ഒന്നോ നൂറുകണക്കിന് സിസ്റ്റം അഡ്മിനിസ്ട്രേറ്റർമാരുടെയോ ഒരു ടീമിന് അത് പരിപാലിക്കാനാകും.

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

പൊതുവേ, പപ്പറ്റ് എല്ലാം ചെയ്യുന്നു സാധ്യമായ പ്രവർത്തനങ്ങൾനിലവിലുള്ള ഒരു സിസ്റ്റത്തിന്റെ പ്രവർത്തനങ്ങൾ അവരുടെ ജോലി നിർവഹിക്കുന്നതിന് ഉപയോഗിക്കാൻ ലക്ഷ്യമിടുന്നു; അതായത്, RedHat സാങ്കേതികവിദ്യകളെ അടിസ്ഥാനമാക്കിയുള്ള വിതരണങ്ങളിൽ, ഇത് പാക്കേജുകൾ നിയന്ത്രിക്കാൻ yum യൂട്ടിലിറ്റിയും സേവനങ്ങൾ നിയന്ത്രിക്കാൻ init.d ഉം ഉപയോഗിക്കും, OS X-ൽ പാക്കേജുകൾ നിയന്ത്രിക്കാനും സേവനങ്ങൾ നിയന്ത്രിക്കാനും ലോഞ്ച് ചെയ്യാനും dmg യൂട്ടിലിറ്റി ഉപയോഗിക്കും. പപ്പറ്റ് പ്രോജക്‌റ്റിന്റെ അടിസ്ഥാന ലക്ഷ്യങ്ങളിലൊന്ന്, പപ്പറ്റ് പ്രോജക്‌റ്റ് കോഡോ അല്ലെങ്കിൽ സിസ്റ്റം തന്നെയോ ഉപയോഗിച്ച് ഉപയോഗപ്രദമായ സൃഷ്ടികൾ നിർമ്മിക്കുക എന്നതാണ്, അതിനാൽ ഇനിപ്പറയുന്ന സിസ്റ്റം മാനദണ്ഡങ്ങൾ നിർണായകമാണ്.

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

പപ്പറ്റ് എങ്ങനെ ഉപയോഗിക്കാമെന്നതിന്റെ ഒരു ലളിതമായ ഉദാഹരണമെന്ന നിലയിൽ, സെക്യുർ ഷെൽ (എസ്എസ്എച്ച്) സേവനം ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെന്നും ശരിയായി കോൺഫിഗർ ചെയ്തിട്ടുണ്ടെന്നും ഉറപ്പാക്കുന്നതിനുള്ള ഒരു കോഡ് സ്നിപ്പറ്റ് ഇതാ: ക്ലാസ് ssh ( പാക്കേജ് ( ssh: ഉറപ്പാക്കുക => ഇൻസ്റ്റാൾ ) ഫയൽ ( "/etc/ssh /sshd_config ": source => "puppet:///modules/ssh/sshd_config", ഉറപ്പാക്കുക => ഉണ്ട്, => പാക്കേജ് ) സേവനം (sshd: ഉറപ്പാക്കുക => പ്രവർത്തിക്കുന്നു, ആവശ്യമാണ് => , പാക്കേജ്] ) )

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

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

പപ്പറ്റുമായുള്ള മിക്ക ഇടപെടലുകളും ഉപയോഗിച്ചാണ് ചെയ്യുന്നത് ഷെൽഅല്ലെങ്കിൽ എല്ലായ്‌പ്പോഴും എച്ച്ടിടിപി സേവനങ്ങൾ പ്രവർത്തിക്കുന്നു, പക്ഷേ റിപ്പോർട്ടുകൾ പ്രോസസ്സ് ചെയ്യുന്നത് പോലുള്ള ജോലികൾ ചെയ്യുന്നതിന് ഗ്രാഫിക്കൽ ഇന്റർഫേസുകളും ഉണ്ട്. വെബ് ജിയുഐകൾ ഉപയോഗിക്കുന്ന വാണിജ്യ പപ്പറ്റ് സോഫ്റ്റ്‌വെയർ ഉൽപ്പന്നങ്ങളും പപ്പറ്റ് ലാബ്സ് നൽകുന്നു.

ആദ്യത്തെ പപ്പറ്റ് പ്രോട്ടോടൈപ്പ് 2004 ലെ വേനൽക്കാലത്ത് വികസിപ്പിച്ചെടുത്തു, പദ്ധതിയുടെ പൂർണ്ണ വികസനം 2005 ഫെബ്രുവരിയിൽ ആരംഭിച്ചു. ചെറിയ ടൂളുകൾ വികസിപ്പിക്കുന്നതിൽ വിപുലമായ അനുഭവമുള്ള ഒരു സിസ്റ്റം അഡ്മിനിസ്‌ട്രേറ്ററായ ലൂക്ക് കാനിസ് ആണ് ഇത് യഥാർത്ഥത്തിൽ രൂപകൽപ്പന ചെയ്ത് വികസിപ്പിച്ചെടുത്തത്, എന്നാൽ 10,000-ലധികം ലൈനുകൾ അടങ്ങിയ പ്രോജക്റ്റുകൾ വികസിപ്പിക്കുന്നതിൽ അനുഭവമില്ല. അടിസ്ഥാനപരമായി, പപ്പറ്റ് പ്രോജക്റ്റിന്റെ വികസന സമയത്ത് ലൂക്ക് കാനിസ് പ്രോഗ്രാമിംഗ് കഴിവുകൾ പഠിച്ചു, ഇത് പ്രോജക്റ്റിന്റെ വാസ്തുവിദ്യയെ അനുകൂലമായും പ്രതികൂലമായും ബാധിച്ചു.

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

തന്നിരിക്കുന്ന നോഡിന് പപ്പറ്റ് ഉറവിടങ്ങൾ അദ്വിതീയമായിരിക്കണം. നിങ്ങൾക്ക് "ssh" എന്ന പേരിലുള്ള ഒരു പാക്കേജും "sshd" എന്ന പേരിലുള്ള ഒരു സേവനവും "/etc/ssh/sshd_config" എന്ന പേരിലുള്ള ഒരു ഫയലും മാത്രമേ ഉണ്ടാകൂ. ഈ പരിമിതി നിങ്ങളുടെ കോൺഫിഗറേഷനുകളുടെ വിവിധ ഭാഗങ്ങൾ തമ്മിലുള്ള പരസ്പര വൈരുദ്ധ്യങ്ങളെ തടയുന്നു, കോൺഫിഗറേഷൻ പ്രക്രിയയുടെ തുടക്കത്തിൽ തന്നെ ഈ വൈരുദ്ധ്യങ്ങളെക്കുറിച്ച് നിങ്ങൾക്ക് ബോധ്യമാകും. ഈ വിഭവങ്ങളെ അവയുടെ തരങ്ങളും പേരുകളും, അതായത്, പാക്കേജും സേവനവും ഉപയോഗിച്ച് ഞങ്ങൾ പരാമർശിക്കുന്നു. നിങ്ങൾക്ക് ഒരേ പേരിൽ ഒരു പാക്കേജും സേവനവും ഉണ്ടായിരിക്കാം, കാരണം അവ വ്യത്യസ്ത തരങ്ങളാണ്, എന്നാൽ ഒരേ പേരിലുള്ള രണ്ട് പാക്കേജുകളോ സേവനങ്ങളോ അല്ല.

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

പപ്പറ്റിന്റെ അവസാനത്തെ പ്രധാന ഘടകം കോൺഫിഗറേഷൻ ഭാഷയാണ്. ഈ ഭാഷ ഡിക്ലറേറ്റീവ് ആണ്, കൂടാതെ പൂർണ്ണമായ പ്രോഗ്രാമിംഗിനേക്കാൾ കോൺഫിഗറേഷൻ വിവരിക്കാൻ ഉദ്ദേശിച്ചുള്ളതാണ് - ഇത് ഏതാണ്ട് പൂർണ്ണമായും നാഗിയോസ് കോൺഫിഗറേഷൻ ഫോർമാറ്റ് ആവർത്തിക്കുന്നു, പക്ഷേ CFEngine, Ruby എന്നിവയിൽ നിന്നുള്ള ഭാഷകളിൽ നിന്നുള്ള കാര്യമായ സ്വാധീനത്തിലാണ് ഇത് സൃഷ്ടിച്ചത്.

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

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

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

റോളിൽ നിങ്ങളെത്തന്നെ സങ്കൽപ്പിക്കുക സിസ്റ്റം അഡ്മിനിസ്ട്രേറ്റർ, UNIX പോലുള്ള ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിൽ പ്രവർത്തിക്കുന്ന നൂറുകണക്കിന് മെഷീനുകളുടെ പ്രവർത്തനക്ഷമത നിലനിർത്തുന്നതിനുള്ള ഉത്തരവാദിത്തം. ഓരോന്നിനും കോൺഫിഗറേഷനും ആനുകാലിക അപ്‌ഡേറ്റും നിരീക്ഷണവും ആവശ്യമാണ്, എന്നാൽ പലതും സമാനമായ പ്രവർത്തനങ്ങൾ നിർവഹിക്കുമെന്ന് പ്രതീക്ഷിക്കുന്നു. മൂന്നിൽ രണ്ട് ഭാഗവും വർക്ക്സ്റ്റേഷനുകളാണ്, കുറച്ച് കൂടി റൂട്ടറുകളാണ്, ബാക്കിയുള്ളവ നിരവധി വെബ് സെർവറുകളും ഡാറ്റ സംഭരണവുമാണ്. ചോദ്യം: ഈ ബിസിനസ്സെല്ലാം എങ്ങനെ കൈകാര്യം ചെയ്യാം?

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

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

പാവയോ?

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

മൊത്തത്തിൽ, പപ്പറ്റ് കൂടുതൽ ആധുനികവും നന്നായി രൂപകല്പന ചെയ്തതുമായ ഒരു സംവിധാനമായി മാറുന്നു. Cfengine പോലെ, ഇത് മിക്കവാറും എല്ലാ ആധുനിക UNIX പോലുള്ള ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളെയും (MacOS X ഉൾപ്പെടെ) പിന്തുണയ്ക്കുന്നു, കൂടാതെ Windows-ന് മുകളിലുള്ള Cygwin പരിതസ്ഥിതിയിലും പ്രവർത്തിക്കാൻ കഴിയും. അതിന്റെ ഡിപൻഡൻസി ലിസ്റ്റിൽ റൂബി ഇന്റർപ്രെറ്ററും ഫാക്ടർ ടൂളും മാത്രമേ ഉൾപ്പെട്ടിട്ടുള്ളൂ, അതിനാൽ ഇൻസ്റ്റാളേഷനിൽ പ്രശ്‌നങ്ങളൊന്നും ഉണ്ടാകരുത് (ന്യായമായി പറഞ്ഞാൽ, Cfengine-ന്റെ ഡിപൻഡൻസി ലിസ്റ്റ് ഇതിലും ചെറുതാണ്).

ഫയൽ സെർവർ

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

ഫയൽ സെർവർ ക്രമീകരണങ്ങൾ /etc/puppet/fileserver.conf ഫയലിൽ സംഭരിച്ചിരിക്കുന്നു. ഒരു നിർദ്ദിഷ്ട ഡയറക്ടറിയുടെ ഉള്ളടക്കം ക്ലയന്റുകൾക്ക് നൽകാൻ പപ്പറ്റിനെ നിർബന്ധിക്കുന്നതിന്, നിങ്ങൾ അതിൽ കുറച്ച് വരികൾ ഇടേണ്ടതുണ്ട്:

പാത = /var/puppet/files *.server.com അനുവദിക്കുന്നു

server.com ഡൊമെയ്‌നിലെ എല്ലാ ഹോസ്റ്റുകൾക്കും /var/puppet/files ഡയറക്‌ടറി ആക്‌സസ് ചെയ്യാൻ കഴിയുമെന്ന് ഈ രണ്ട് വരികൾ സൂചിപ്പിക്കുന്നു. അനുവദനീയമായ മെഷീന്റെ പൂർണ്ണമായ ഡൊമെയ്‌ൻ നാമം അല്ലെങ്കിൽ അതിന്റെ ഐപി വിലാസം വ്യക്തമാക്കാനും, നിരസിക്കാനുള്ള നിർദ്ദേശം ഉപയോഗിച്ച് ആവശ്യമില്ലാത്തവ മുറിച്ചുമാറ്റാനും കഴിയും. ആ ഡയറക്ടറിയിലെ ഏത് ഫയലും ഫയൽ റിസോഴ്സ് ഉപയോഗിച്ച് ക്ലയന്റിലേക്ക് നീക്കാൻ കഴിയും. ഉദാഹരണത്തിന്:

ഫയൽ ("/etc/httpd/conf/httpd.conf": ഉറവിടം => "puppet://httpd/httpd.conf", മോഡ് => 644, )

/var/puppet/files/httpd ഡയറക്‌ടറിയിലെ സെർവറിൽ സ്ഥിതി ചെയ്യുന്ന httpd.conf ഫയൽ റിസോഴ്‌സ് നാമത്തിൽ വ്യക്തമാക്കിയ പാതയിലൂടെ ടാർഗെറ്റ് മെഷീനിലേക്ക് പകർത്തപ്പെടും.

നിഗമനങ്ങൾ

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

അധികം താമസിയാതെ, മാസികയുടെ പേജുകളിൽ, UNIX മെഷീനുകൾക്കായുള്ള Cfengine റിമോട്ട് കോൺഫിഗറേഷൻ മാനേജുമെന്റ് സിസ്റ്റം ഞങ്ങൾ പരിശോധിച്ചു, ഇത് നിരവധി നെറ്റ്‌വർക്ക് നോഡുകൾ കോൺഫിഗർ ചെയ്യുന്നതിനുള്ള ഘട്ടങ്ങൾ ഓട്ടോമേറ്റ് ചെയ്തുകൊണ്ട് ഒരു സിസ്റ്റം അഡ്മിനിസ്ട്രേറ്ററുടെ ജീവിതത്തെ വളരെ ലളിതമാക്കുന്നു. പക്ഷേ, Cfengine എത്ര സൗകര്യപ്രദമാണെങ്കിലും, പപ്പറ്റ് എന്ന സംവിധാനത്തിന് ഇല്ലാത്ത പല ദോഷങ്ങളുമുണ്ട്.

UNIX-തരം ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ പ്രവർത്തിക്കുന്ന നൂറുകണക്കിന് മെഷീനുകളുടെ പ്രവർത്തനക്ഷമത നിലനിർത്തുന്നതിന് ഉത്തരവാദിത്തമുള്ള ഒരു സിസ്റ്റം അഡ്മിനിസ്ട്രേറ്ററുടെ റോളിൽ നിങ്ങൾ സ്വയം സങ്കൽപ്പിക്കുക. അവയിൽ ഓരോന്നിനും കോൺഫിഗറേഷൻ, ആനുകാലിക അപ്‌ഡേറ്റ്, നിരീക്ഷണം എന്നിവ ആവശ്യമാണ്, അവയിൽ പലതും സമാനമായ പ്രവർത്തനങ്ങൾ നടത്തുന്നുവെന്ന് അനുമാനിക്കപ്പെടുന്നു.

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

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

പാവയോ?

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

കൂടാതെ, ഒരു വ്യക്തിയെ ചുറ്റിപ്പറ്റിയുള്ള Cfengine ന്റെ വികസന മാതൃകയിൽ നിന്ന് വ്യത്യസ്തമായി, പപ്പറ്റിന് കോഡിൽ മെച്ചപ്പെടുത്തലുകൾ വരുത്തുകയും കോൺഫിഗറേഷൻ ഉദാഹരണങ്ങൾ പങ്കിടുകയും ഡോക്യുമെന്റേഷൻ എഴുതുകയും ചെയ്യുന്ന ഒരു വലിയ കമ്മ്യൂണിറ്റിയുണ്ട്.

ഇൻസ്റ്റലേഷൻ

Cfengne പോലെ, പപ്പറ്റ് ഒരു കൺട്രോൾ സെർവറും സ്ലേവ് നോഡുകളും അടങ്ങുന്ന ഒരു ക്ലയന്റ്-സെർവർ സിസ്റ്റമാണ്. നോഡുകളുടെ അന്തിമ അവസ്ഥകളുടെ ഒരു വിവരണം സെർവർ സംഭരിക്കുന്നു (പപ്പറ്റ് പദങ്ങളിൽ ഇതിനെ മാനിഫെസ്റ്റ് എന്ന് വിളിക്കുന്നു) അവ കണക്റ്റുചെയ്യുന്നതിനായി കാത്തിരിക്കുന്നു. ഓരോ അരമണിക്കൂറിലും (സ്ഥിരസ്ഥിതിയായി), ക്ലയന്റ് സെർവറിലേക്ക് കണക്റ്റുചെയ്യുന്നു, അതിൽ നിന്ന് അന്തിമ അവസ്ഥയുടെ ഒരു വിവരണം സ്വീകരിക്കുന്നു, നിലവിലുള്ള അവസ്ഥയുമായി താരതമ്യം ചെയ്യുന്നു, കൂടാതെ അത് കൂടാതെ/അല്ലെങ്കിൽ വിവരിച്ച അവസ്ഥ മാറിയിട്ടുണ്ടെങ്കിൽ, സിസ്റ്റം പുനഃക്രമീകരിക്കുന്നു, തുടർന്ന് ഉറങ്ങാൻ പോകുന്നു. ഒരു എൻക്രിപ്റ്റ് ചെയ്ത ചാനലിലൂടെയാണ് ആശയവിനിമയം നടത്തുന്നത്, അതിനാൽ സംസ്ഥാന വിവരണത്തിന്റെ പകരക്കാരനെ അടിസ്ഥാനമാക്കിയുള്ള ആക്രമണങ്ങൾ ഒഴിവാക്കിയിരിക്കുന്നു (എന്നാൽ ഒരു ആക്രമണകാരി സെർവർ ഏറ്റെടുക്കുകയാണെങ്കിൽ, എല്ലാ നോഡുകളും അവന്റെ നിയന്ത്രണത്തിലായിരിക്കും).

എല്ലാ ജനപ്രിയ വിതരണങ്ങളുടെയും റിപ്പോസിറ്ററികളിൽ പപ്പറ്റ് ഉൾപ്പെടുത്തിയിട്ടുണ്ട്, അതിനാൽ ഇത് ഇൻസ്റ്റാൾ ചെയ്യുന്നത് ബുദ്ധിമുട്ടുള്ള കാര്യമല്ല. ഉദാഹരണത്തിന്, ഡെബിയൻ/ഉബുണ്ടുവിൽ പപ്പറ്റ് ക്ലയന്റ് ഇതുപോലെ ഇൻസ്റ്റാൾ ചെയ്യാൻ കഴിയും:

$ sudo apt-get install puppet

സെർവർ ഇതുപോലെയാണ്:

$ sudo apt-get install puppet puppetmaster

ക്ലയന്റ്, സെർവർ കോൺഫിഗറേഷൻ ഫയലുകൾ /etc/puppet ഡയറക്ടറിയിൽ സംഭരിച്ചിരിക്കുന്നു. ഇതിൽ ഏറ്റവും പ്രധാനപ്പെട്ടത് മാനിഫെസ്റ്റ് അടങ്ങുന്ന /etc/puppet/manifests/site.pp എന്ന ഫയൽ ആണ്.

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

ക്ലാസ് പാസ്വേഡ് (
ഫയൽ("/etc/passwd":
ഉടമ => റൂട്ട്,
ഗ്രൂപ്പ് => റൂട്ട്,
മോഡ് => 644,
}
}
നോഡ് ഡിഫോൾട്ട് (
പാസ്‌വേഡ് ഉൾപ്പെടുന്നു
}

/etc/passwd ഫയലിന്റെ ഉടമ റൂട്ട് ആയിരിക്കണം കൂടാതെ അതിന്റെ അനുമതികൾ 644 ആയി സജ്ജീകരിച്ചിരിക്കുന്ന അവസ്ഥയെ ഈ വരികൾ വിവരിക്കുന്നു. അടുത്ത വിഭാഗത്തിലെ മാനിഫെസ്റ്റ് ഫയൽ ഫോർമാറ്റ് ഞങ്ങൾ സൂക്ഷ്മമായി പരിശോധിക്കും. രണ്ടാമത്തെ ഏറ്റവും പ്രധാനപ്പെട്ട ഫയൽ /etc/puppet/puppet.conf ആണ്. ഇത് സെർവറിന്റെയും ക്ലയന്റുകളുടെയും കോൺഫിഗറേഷൻ സജ്ജമാക്കുന്നു, അതിനാൽ പപ്പറ്റ് നെറ്റ്‌വർക്കിൽ ഓർഗനൈസുചെയ്‌ത എല്ലാ മെഷീനുകളിലും ഇത് ഉണ്ടായിരിക്കണം. ഉബുണ്ടുവിൽ, ഈ ഫയലിൽ ആവശ്യമായ ഏറ്റവും കുറഞ്ഞതും മിക്ക കേസുകളിലും മതിയായതുമായ ക്രമീകരണങ്ങൾ അടങ്ങിയിരിക്കുന്നു. അവ താഴെ കമന്റുകൾക്കൊപ്പം നൽകിയിരിക്കുന്നു:

# vi /etc/puppet/puppet.conf
# സ്റ്റാൻഡേർഡ് ഡയറക്ടറി പാതകൾ
logdir=/var/log/puppet
vardir=/var/lib/puppet
ssldir=/var/lib/puppet/ssl
രുണ്ടിർ=/var/റൺ/പാവ
# ഫാക്ടർ ടൂൾ ലൊക്കേഷൻ,
# OS-നെക്കുറിച്ചുള്ള വിവരങ്ങൾ ലഭിക്കാൻ ഉപയോഗിക്കുന്നു
വസ്തുതപാത്ത്=$vardir/lib/factor
# പ്ലഗിനുകൾ സമന്വയിപ്പിക്കുക
# (സെർവറിൽ പ്ലഗിനുകൾ ഇൻസ്റ്റാൾ ചെയ്തു - അവ ക്ലയന്റുകളിലേക്ക് പകർത്തി)
pluginsync=true
# ടെംപ്ലേറ്റുകളുള്ള കാറ്റലോഗ് (അവയെക്കുറിച്ച് ചുവടെ വായിക്കുക)
templatedir=$confdir/ടെംപ്ലേറ്റുകൾ
# etc കീപ്പറുമായുള്ള സമന്വയം
# (ആർക്കറിയാം, മനസ്സിലാകും, മറ്റുള്ളവർക്ക് ഇത് ആവശ്യമില്ല)
prerun_command=/etc/puppet/etckeeper-commitpre
postrun_command=/etc/puppet/etckeeper-commitpost

കോൺഫിഗറേഷൻ ഫയലിൽ ഉൾപ്പെട്ടേക്കാം ഒരു വലിയ സംഖ്യവിവിധ ഓപ്ഷനുകൾ, ഒരു ഡിഫോൾട്ട് കോൺഫിഗറേഷൻ സൃഷ്ടിച്ചുകൊണ്ട് അവയെക്കുറിച്ചുള്ള വിവരങ്ങൾ ലഭിക്കും:

$ sudo puppetmasterd -genconfig > /etc/puppet/
puppetd.conf.default

ഡിഫോൾട്ട് ക്ലയന്റ് കോൺഫിഗറേഷൻ മറ്റൊരു കമാൻഡ് ഉപയോഗിച്ച് ജനറേറ്റ് ചെയ്യുന്നു:

$ sudo puppet -genconfig > /etc/puppet/puppetd.conf.default

ഫയൽ സെർവർ കോൺഫിഗർ ചെയ്യുന്നതിന് fileserver.conf, auth.conf എന്നീ ഫയലുകൾ ഉപയോഗിക്കുന്നു (ഇതിനെക്കുറിച്ച് "ഫയൽ സെർവർ" വിഭാഗത്തിൽ വായിക്കുക) പ്രാമാണീകരണവും. ഇതുവരെ അവരെ തൊടുന്നതിൽ അർത്ഥമില്ല. കോൺഫിഗറേഷൻ പൂർത്തിയായിക്കഴിഞ്ഞാൽ, പപ്പറ്റ് സെർവർ പുനരാരംഭിക്കണം:

$ sudo /etc/init.d/puppetmaster പുനരാരംഭിക്കുക

അതിനുശേഷം ഉപഭോക്തൃ അഭ്യർത്ഥനകൾ സ്വീകരിക്കാൻ അദ്ദേഹം തയ്യാറാകും. എന്നിരുന്നാലും, ഒപ്പിട്ട സർട്ടിഫിക്കറ്റില്ലാതെ, ഒരു ക്ലയന്റിനും സെർവറിൽ നിന്ന് മാനിഫെസ്റ്റ് സ്വീകരിക്കാനും മെഷീൻ കോൺഫിഗർ ചെയ്യാനും കഴിയില്ല.

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

$ sudo puppetd -server puppet-server.com -verbose -test

ഞങ്ങൾ സെർവറിലേക്ക് മടങ്ങുകയും ഒപ്പിടുന്നതിന് തയ്യാറായ സർട്ടിഫിക്കറ്റുകളുടെ ഒരു ലിസ്റ്റ് സ്വീകരിക്കുകയും ചെയ്യുന്നു:

$ sudo puppetca --list

ലിസ്റ്റിൽ നിന്ന് ഒരു ഹോസ്റ്റ് തിരഞ്ഞെടുത്ത് അതിന്റെ സർട്ടിഫിക്കറ്റിൽ ഒപ്പിടുക:

$ sudo puppetca --sign nomad.grinder.com

അല്ലെങ്കിൽ ഞങ്ങൾ എല്ലാം ഒരേസമയം ഒപ്പിടുന്നു:

$ sudo puppetca --sign --all

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

$സുഡോ സു
# echo "" >> /etc/puppet/puppet.conf
# echo "server=puppet-server.com" >> /etc/puppet/puppet.conf
# പുറത്ത്

ക്ലയന്റുകളെ സമാരംഭിക്കുന്നു:

$ sudo /etc/init.d/puppet start

സംസ്ഥാന വിവരണ ഭാഷ

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

# vi /etc/puppet/manifests/site.pp
ഫയൽ("/etc/passwd":
ഉടമ => "റൂട്ട്"
}

ഇവിടെ ഫയൽ റിസോഴ്സ് തരമാണ്. ഫയലുകൾ കൈകാര്യം ചെയ്യുന്ന ഉറവിടങ്ങൾ മുതൽ പാക്കേജുകളും സേവനങ്ങളും വരെ, ഈ ഉദാഹരണത്തിലെന്നപോലെ, മൊത്തത്തിൽ അവയിൽ നിരവധി ഡസൻ ഉണ്ട്. ലൈൻ /etc/passwd എന്നത് ഉറവിടത്തിന്റെ പേരാണ്.

ഫയൽ തരത്തിന്റെ കാര്യത്തിൽ, പേര് ഫയലിലേക്കുള്ള പാതയ്ക്ക് തുല്യമാണ്, എന്നാൽ മറ്റ് ചില തരങ്ങളിൽ പേര് ഏകപക്ഷീയമായിരിക്കാം. ലൈൻ ഉടമ => "റൂട്ട്", ഉടമയുടെ ആട്രിബ്യൂട്ട് റൂട്ടിലേക്ക് സജ്ജീകരിക്കുന്നത് വിവരിക്കുന്നു, അതായത്, അത് ഉടമ പറയുന്നു വ്യക്തമാക്കിയ ഫയൽഒരു അഡ്മിനിസ്ട്രേറ്റർ ഉണ്ടായിരിക്കണം.

ഓരോ തരത്തിലുള്ള റിസോഴ്സിനും പരിഷ്ക്കരണത്തിനായി അതിന്റേതായ ആട്രിബ്യൂട്ടുകൾ ലഭ്യമാണ്, കൂടാതെ ഏത് റിസോഴ്സിലും ഉപയോഗിക്കാവുന്ന പ്രത്യേക മെറ്റാ ആട്രിബ്യൂട്ടുകളും ഉണ്ട്. വിഭവങ്ങളുടെ ഒരു പ്രധാന ഗുണം അവയുമായി ബന്ധിപ്പിക്കാനുള്ള കഴിവാണ്. ഡിപൻഡൻസി ചെയിനുകൾ രൂപപ്പെടുത്താൻ ഇത് ഉപയോഗിക്കാം. അടുത്ത എൻട്രി/etc/passwd റിസോഴ്സിനെ ആശ്രയിക്കുന്ന ഒരു /etc/group റിസോഴ്സ് സൃഷ്ടിക്കുന്നു (ആശ്രിതത്വം ആവശ്യമുള്ള മെറ്റാ ആട്രിബ്യൂട്ട് ഉപയോഗിച്ചാണ് വ്യക്തമാക്കുന്നത്):

# vi /etc/puppet/manifests/site.pp
ഫയൽ("/etc/group":
ആവശ്യമാണ് => ഫയൽ["/etc/passwd"],
ഉടമ => "റൂട്ട്",
}

ഇതിനർത്ഥം /etc/passwd റിസോഴ്സ് കോൺഫിഗർ ചെയ്യുമ്പോൾ മാത്രമേ /etc/group റിസോഴ്സ് ക്രമീകരിക്കാൻ കഴിയൂ (വിവരിച്ച ഫോമിലേക്ക് കൊണ്ടുവരിക). ഉറവിടങ്ങളെ ക്ലാസുകൾ എന്ന് വിളിക്കുന്ന വിഭവങ്ങളുടെ ശേഖരങ്ങളായി തരം തിരിക്കാം. നിർവ്വഹിക്കുന്ന ജോലിയുടെ അർത്ഥത്തിലും തരത്തിലും സമാനമായ ഉറവിടങ്ങളെ ഒരു അമൂർത്ത വിഭവത്തിലേക്ക് സംയോജിപ്പിക്കുന്നതിന് ഇത് ആവശ്യമാണ്. ഉദാഹരണത്തിന്, സൗകര്യാർത്ഥം നമുക്ക് ഇൻസ്റ്റാളേഷനും ലോഞ്ചും സംയോജിപ്പിക്കാം nginx വെബ് സെർവർഅതേ പേരിലുള്ള ഒരു അമൂർത്ത വിഭവത്തിലേക്ക്:

# vi /etc/puppet/manifests/site.pp
ക്ലാസ് nginx(
പാക്കേജ് ("nginx":
=> ഇൻസ്റ്റാൾ ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കുക
}
സേവനം("nginx":
=> പ്രവർത്തിക്കുന്നത് ഉറപ്പാക്കുക,
ആവശ്യമാണ് => പാക്കേജ്["nginx"],
}
}

ഇവിടെ, സിസ്റ്റത്തിൽ nginx പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്യാൻ പാക്കേജ് റിസോഴ്സ് തരം ഉപയോഗിക്കുന്നു, അതേ പേരിലുള്ള സേവനം സമാരംഭിക്കുന്നതിന് സേവനം ഉപയോഗിക്കുന്നു. പാക്കേജ് വിജയകരമായി ഇൻസ്‌റ്റാൾ ചെയ്‌തിട്ടുണ്ടെങ്കിൽ മാത്രം സേവനം ആരംഭിക്കാൻ ഞങ്ങൾ സിസ്റ്റത്തെ നിർബന്ധിക്കുന്നു. ക്ലാസുകളുടെ സൗകര്യം ഇനിപ്പറയുന്നവയെ ആശ്രയിച്ച് അവയും ഉൾപ്പെടുത്താം എന്നതാണ്:

# vi /etc/puppet/manifests/site.pp
സേവനം ("കണവ":
=> പ്രവർത്തിക്കുന്നത് ഉറപ്പാക്കുക,
ആവശ്യമാണ് => ക്ലാസ്["nginx"],
}

യഥാർത്ഥ OOP ഭാഷകളിലെന്നപോലെ, ക്ലാസുകൾക്ക് പരസ്പരം അവകാശമാക്കാനും ആട്രിബ്യൂട്ടുകൾ അസാധുവാക്കാനും കഴിയും:

# vi /etc/puppet/manifests/site.pp
ക്ലാസ് പാസ്വേഡ് (
ഫയൽ("/etc/passwd":
ഉടമ => "റൂട്ട്",
ഗ്രൂപ്പ് => "റൂട്ട്",
}
}
ക്ലാസ് പാസ്‌ഡബ്ല്യുഡി-ബിഎസ്‌ഡി പാസ്‌ഡബ്ല്യുഡി പാരമ്പര്യമായി ലഭിക്കുന്നു (
ഫയൽ["/etc/passwd"] (ഗ്രൂപ്പ് => "ചക്രം" )
}

/etc/passwd റിസോഴ്സിന്റെ (BSD സിസ്റ്റങ്ങളിൽ /etc/passwd ഉൾപ്പെടുന്നതാണ്) ഗ്രൂപ്പ് ആട്രിബ്യൂട്ട് അസാധുവാക്കാൻ ഇവിടെ passwd-bsd ക്ലാസ് passwd-ൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്നു. വീൽ ഗ്രൂപ്പ്, അതിനാൽ ഞങ്ങൾ അത്തരം സിസ്റ്റങ്ങൾക്കായി ഒരു പ്രത്യേക ക്ലാസ് സൃഷ്ടിച്ചു). പിന്നീട് നമ്മൾ കൂടുതൽ ശരിയായതും നോക്കും വ്യക്തമായ വഴിവ്യവസ്ഥകൾ ഉപയോഗിച്ച് ഇതര ആട്രിബ്യൂട്ട് മൂല്യങ്ങൾ തിരഞ്ഞെടുക്കുന്നു.

ഏതൊരു പ്രോഗ്രാമിംഗ് ഭാഷയുടെയും അവിഭാജ്യ ഘടകങ്ങളിലൊന്നാണ് വേരിയബിളുകൾ, കൂടാതെ പപ്പറ്റിനും അവയുണ്ട്. വേരിയബിളുകൾ $ ചിഹ്നത്തിൽ ആരംഭിക്കുന്നു, അതിൽ ഏത് സംഖ്യയും സ്ട്രിംഗും ബൂളിയൻ മൂല്യവും അടങ്ങിയിരിക്കാം (ശരി, തെറ്റ്):

$want_apache = സത്യം
$apache_version = "2.2.14"

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

ഉദാഹരണത്തിന്, മുകളിൽ വിവരിച്ച പാസ്വേഡ് ക്ലാസ് എളുപ്പത്തിൽ മാറ്റിയെഴുതാൻ കഴിയും യാന്ത്രിക തിരഞ്ഞെടുപ്പ് OS തരത്തെ ആശ്രയിച്ച് ആട്രിബ്യൂട്ട് (ഈ സാഹചര്യത്തിൽ, ക്ലാസ് തന്നെ ഇനി ആവശ്യമില്ല):

# vi /etc/puppet/manifests/site.pp
ഫയൽ("/etc/passwd":
ഉടമ => "റൂട്ട്",
ഗ്രൂപ്പ് => $കെർണൽ ? (
Linux => "റൂട്ട്",
FreeBSD => "ചക്രം",
},
}

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

# vi /etc/puppet/manifests/site.pp
കേസ് $operatingsystem (
redhat: (സേവനം("httpd": ഉറപ്പാക്കുക => പ്രവർത്തിക്കുന്നു))
debian: (സർവീസ്("അപ്പാച്ചെ": ഉറപ്പാക്കുക => പ്രവർത്തിക്കുന്നു))
സ്ഥിരസ്ഥിതി: ( സേവനം ( "apache2": ഉറപ്പാക്കുക =>
പ്രവർത്തിക്കുന്ന))
}

ഈ കോഡ് നിർവചിക്കുന്നു വിവിധ ഓപ്ഷനുകൾഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തെ ആശ്രയിച്ച് തരം സേവനത്തിന്റെ ഉറവിടം (വ്യത്യസ്‌ത ലിനക്‌സ് വിതരണങ്ങളിലെ സേവനങ്ങളുടെ പേരുകൾ വ്യത്യാസപ്പെടാം, അതിനാൽ ഏത് സേവനമാണ് പപ്പറ്റ് പ്രവർത്തിപ്പിക്കേണ്ടതെന്ന് അവ ഓരോന്നിനും വ്യക്തിഗതമായി വ്യക്തമാക്കണം).

വേരിയബിളിന്റെ മൂല്യം മുമ്പത്തെ ഏതെങ്കിലും ഓപ്ഷനുകളുമായി പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ ഡിഫോൾട്ട് ഓപ്ഷൻ ഉപയോഗിക്കുന്നു. മുമ്പ് ചർച്ച ചെയ്ത റിസോഴ്‌സ് തരങ്ങൾക്ക് പുറമേ, സൃഷ്ടിച്ചവ ഉൾപ്പെടെ, പപ്പറ്റ് മറ്റ് നിരവധി പേരെ പിന്തുണയ്ക്കുന്നു. മൂന്നാം കക്ഷി ഡെവലപ്പർമാർവിഭവങ്ങളുടെ തരങ്ങൾ. ഉദാഹരണങ്ങൾ, പിന്തുണയ്ക്കുന്ന ആട്രിബ്യൂട്ടുകൾ, ഫീച്ചറുകൾ എന്നിവയുൾപ്പെടെ അവയുടെ വിശദമായ വിവരണം ഇതിൽ കാണാം ഔദ്യോഗിക ഡോക്യുമെന്റേഷൻ- http://docs.puppetlabs.com/references/stable/type.html. ഏറ്റവും കൂടുതൽ ഉപയോഗിക്കുന്നവയുടെ ഒരു ലിസ്റ്റും ഹ്രസ്വ വിവരണവും ചുവടെ:

ജനപ്രിയ പപ്പറ്റ് റിസോഴ്സ് തരങ്ങൾ

ക്രോൺ - ക്രോൺ ജോലികൾ കൈകാര്യം ചെയ്യുക
exec - സ്ക്രിപ്റ്റുകളും കമാൻഡുകളും പ്രവർത്തിപ്പിക്കുക
ഫയൽ - ഫയൽ മാനേജ്മെന്റ്
ഫയൽ ബക്കറ്റ് - ബാക്കപ്പ്ഫയലുകൾ
ഗ്രൂപ്പ് - ഗ്രൂപ്പ് മാനേജ്മെന്റ്
ഹോസ്റ്റ് - /etc/hosts ഫയലിലെ എൻട്രികൾ കൈകാര്യം ചെയ്യുക
ഇന്റർഫേസ് - നെറ്റ്‌വർക്ക് ഇന്റർഫേസുകളുടെ കോൺഫിഗറേഷൻ
മൗണ്ട് - ഫയൽ സിസ്റ്റങ്ങൾ മൗണ്ടുചെയ്യുന്നു
അറിയിക്കുക - പപ്പറ്റ് ലോഗ് ഫയലിലേക്ക് ഒരു സന്ദേശം അയയ്ക്കുക
പാക്കേജ് - പാക്കേജ് മാനേജ്മെന്റ്
സേവനം - സേവന മാനേജ്മെന്റ്
sshkey - SSH കീകൾ കൈകാര്യം ചെയ്യുക
tidy - വ്യവസ്ഥകൾ അനുസരിച്ച് ഫയലുകൾ ഇല്ലാതാക്കുന്നു
ഉപയോക്താവ് - ഉപയോക്തൃ മാനേജ്മെന്റ്
സോണുകൾ - സോളാരിസ് സോൺ മാനേജ്മെന്റ്

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

# vi /etc/puppet/manifests/site.pp
നോഡ് ഡിഫോൾട്ട് (
പാസ്‌വേഡ് ഉൾപ്പെടുന്നു
}

പാസ്‌വേഡ് റിസോഴ്‌സ്/ക്ലാസ് ഉൾപ്പെടുന്ന ഡിഫോൾട്ട് നോഡിന്റെ നിർവചനമാണിത്. ഡിഫോൾട്ട് എന്ന പേരിന്റെ അർത്ഥം "മറ്റെല്ലാ നോഡുകൾ" എന്നാണ്, അതിനാൽ മുകളിൽ എവിടെയോ നിർവചിച്ചിരിക്കുന്ന പാസ്‌വേഡ് റിസോഴ്‌സ്/ക്ലാസ് അവയിൽ ഓരോന്നിലും കോൺഫിഗർ ചെയ്യപ്പെടും. കീവേഡ്ഉൾപ്പെടുത്തൽ സൗകര്യത്തിനായി ഇവിടെ ഉപയോഗിക്കുന്നു; വാസ്തവത്തിൽ, എല്ലാ ക്ലാസുകളും ഉറവിടങ്ങളും നോഡ് വിവരണത്തിൽ നേരിട്ട് വിവരിക്കാം, എന്നാൽ ഇത് ശുപാർശ ചെയ്യുന്നില്ല. സ്ഥിരസ്ഥിതിക്ക് പുറമേ, നിങ്ങൾക്ക് നോഡ് നാമത്തിൽ വ്യക്തമാക്കാം ശൃംഖലയുടെ പേര്മെഷീൻ (അപ്പോൾ നോഡിൽ വിവരിച്ചിരിക്കുന്ന എല്ലാ ഉറവിടങ്ങളും ഈ മെഷീനിൽ മാത്രമേ കോൺഫിഗർ ചെയ്യപ്പെടുകയുള്ളൂ), അല്ലെങ്കിൽ ഒരു അനിയന്ത്രിതമായ പേര് (അപ്പോൾ ഈ നോഡിന് മറ്റൊരു നോഡ് പാരമ്പര്യമായി ലഭിക്കും). ക്ലാസുകളും ഉറവിടങ്ങളും ഉപയോഗിച്ച് ഇതെല്ലാം എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് മനസിലാക്കാൻ, രണ്ടെണ്ണം കോൺഫിഗർ ചെയ്യാൻ ഉപയോഗിക്കുന്ന ഒരു റെഡിമെയ്ഡ് പപ്പറ്റ് മാനിഫെസ്റ്റിന്റെ ഒരു ഉദാഹരണം നോക്കാം. നെറ്റ്വർക്ക് മെഷീനുകൾ(വെബ് സെർവറും NTP സെർവറും):

# vi /etc/puppet/manifests/site.pp
# ഒരു SSH സെർവർ ഇൻസ്റ്റാൾ ചെയ്യുകയും പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്നു
ക്ലാസ് sshd(
പാക്കേജ് ( openssh-server: ഉറപ്പാക്കുക => ഇൻസ്റ്റാൾ )
സേവനം(sshd:
പേര് => $operatingsystem ? (
ഫെഡോറ => "sshd",
debian => "ssh",
സ്ഥിരസ്ഥിതി => "sshd",
},
പ്രാപ്തമാക്കുക => ശരി,
=> പ്രവർത്തിക്കുന്നത് ഉറപ്പാക്കുക,
}
}
# അപ്പാച്ചെ ഇൻസ്റ്റാൾ ചെയ്ത് പ്രവർത്തിപ്പിക്കുക
ക്ലാസ് httpd(
പാക്കേജ് (httpd: ഉറപ്പാക്കുക => ഇൻസ്റ്റാൾ ചെയ്യുക)
സേവനം(httpd:
പ്രാപ്തമാക്കുക => ശരി,
=> പ്രവർത്തിക്കുന്നത് ഉറപ്പാക്കുക,
}
}
# ഒരു NTP സെർവർ ഇൻസ്റ്റാൾ ചെയ്യുകയും ആരംഭിക്കുകയും ചെയ്യുന്നു
ക്ലാസ് ntpd(
പാക്കേജ് (ntp-server: ഉറപ്പാക്കുക => ഇൻസ്റ്റാൾ ചെയ്തു)
സേവനം (
ntp-server:
പ്രാപ്തമാക്കുക => ശരി,
=> പ്രവർത്തിക്കുന്നത് ഉറപ്പാക്കുക,
}
}
# അടിസ്ഥാന നോഡ്, മറ്റെല്ലാവരുടെയും രക്ഷിതാവായി മാത്രം ഉപയോഗിക്കുന്നു
നോഡ് ബേസ് (
sshd ഉൾപ്പെടുന്നു
}
# വെബ് സെർവർ സ്ഥിതി ചെയ്യുന്ന നോഡ്
നോഡ് web.server.com അടിസ്ഥാനം അവകാശമാക്കുന്നു (
httpd ഉൾപ്പെടുത്തുക
}
# NTP സെർവർ നോഡ്
നോഡ് ntp.server.com അടിസ്ഥാനം അവകാശമാക്കുന്നു (
ntpd ഉൾപ്പെടുന്നു
}

ഈ ലളിതമായ കോൺഫിഗറേഷൻ വളരെയധികം ചെയ്യുന്നു: ഇത് ഇൻസ്റ്റാൾ ചെയ്യുന്നു അപ്പാച്ചെ ആരംഭിക്കുന്നു web.server.com എന്ന വിലാസമുള്ള ഒരു മെഷീനിൽ, മെഷീനിൽ ഒരു NTP സെർവർ ഇൻസ്റ്റാൾ ചെയ്ത് പ്രവർത്തിപ്പിക്കുന്നതിന് ntp.server.com. കൂടാതെ, രണ്ട് മെഷീനുകളും ഒരു SSH സെർവർ ഇൻസ്റ്റാൾ ചെയ്യുന്നു. ഈ കോൺഫിഗറേഷൻ ഒരു അഡ്മിനിസ്ട്രേറ്റർക്ക് പോലും അനുയോജ്യമല്ല; പ്രധാന പപ്പറ്റ് സെർവറിൽ നിന്ന് സെർവറുകൾ എങ്ങനെ ശരിയായി കോൺഫിഗർ ചെയ്യാമെന്നും പുതിയ കോൺഫിഗേഷനുകളും മറ്റ് ഫയലുകളും എങ്ങനെ സ്വീകരിക്കാമെന്നും പഠിപ്പിക്കുന്നതിന് ഇത് ഗൗരവമായി മെച്ചപ്പെടുത്തേണ്ടതുണ്ട്.

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

ഫയൽ സെർവർ

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

# vi /etc/puppet/fileserver.conf
പാത = /var/puppet/files
*.server.com അനുവദിക്കുക

server.com ഡൊമെയ്‌നിലെ എല്ലാ ഹോസ്റ്റുകൾക്കും /var/puppet/files ഡയറക്‌ടറി ആക്‌സസ് ചെയ്യാൻ കഴിയുമെന്ന് ഈ രണ്ട് വരികൾ സൂചിപ്പിക്കുന്നു. കൂടാതെ, ഒരു അനുവദനീയമായ മെഷീന്റെ പൂർണ്ണമായ ഡൊമെയ്ൻ നാമം അല്ലെങ്കിൽ അതിന്റെ IP വിലാസം നമുക്ക് വ്യക്തമാക്കാം, കൂടാതെ നിരസിക്കാനുള്ള നിർദ്ദേശം ഉപയോഗിച്ച് ആവശ്യമില്ലാത്തവ മുറിച്ചുമാറ്റുകയും ചെയ്യാം. ആ ഡയറക്ടറിയിലെ ഏത് ഫയലും ഫയൽ റിസോഴ്സ് ഉപയോഗിച്ച് ക്ലയന്റിലേക്ക് നീക്കാൻ കഴിയും. ഉദാഹരണത്തിന്:

# vi /etc/puppet/manifests/site.pp
ഫയൽ("/etc/httpd/conf/httpd.conf":
ഉറവിടം => "പപ്പറ്റ്://httpd/httpd.conf",
മോഡ് => 644,
}

/var/puppet/files/httpd ഡയറക്‌ടറിയിലെ സെർവറിൽ സ്ഥിതി ചെയ്യുന്ന httpd.conf ഫയൽ, റിസോഴ്‌സ് നാമത്തിൽ വ്യക്തമാക്കിയ പാതയിലൂടെ ടാർഗെറ്റ് മെഷീനിലേക്ക് പകർത്തപ്പെടും.

നിഗമനങ്ങൾ

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

വിവരം

പപ്പറ്റ് HTTP പ്രോട്ടോക്കോൾ ഉപയോഗിക്കുന്നു, അതിനാൽ പ്രകടനം മെച്ചപ്പെടുത്തുന്നതിന് ഒരു വെബ് സെർവറിന് കീഴിൽ ഇത് പ്രവർത്തിപ്പിക്കാം.
ഒരു പ്രാദേശിക യന്ത്രം സ്വയമേവ ക്രമീകരിക്കാനും പരിപാലിക്കാനും പപ്പറ്റ് ഉപയോഗിക്കാം.
പപ്പറ്റ്, നെറ്റ്‌വർക്ക് ഒഎസ് ഇൻസ്റ്റാളേഷൻ (പിഎക്സ്ഇ-ഇൻസ്റ്റാൾ), സ്വയം-ബിൽഡിംഗ് ഇൻസ്റ്റാളേഷൻ ഇമേജുകൾ എന്നിവ സംയോജിപ്പിച്ച്, നിങ്ങൾക്ക് ഒരു കമാൻഡ് ഉപയോഗിച്ച് വിന്യസിക്കാൻ കഴിയുന്ന മെഷീനുകളുടെ പൂർണ്ണമായും സ്വയം ക്രമീകരിക്കുന്ന നെറ്റ്‌വർക്ക് സൃഷ്ടിക്കാൻ കഴിയും.
പലരും അവരുടെ ജോലിയിൽ പപ്പറ്റ് ഉപയോഗിക്കുന്നു. വലിയ കമ്പനികൾ, Google, Fedora Project, Stanford University, Red Hat, Siemens IT Solution, SugarCRM എന്നിവ പോലെ.