పప్పెట్ అనేది కాన్ఫిగరేషన్ మేనేజ్‌మెంట్ సిస్టమ్. ఇది హోస్ట్‌లను కావలసిన స్థితికి తీసుకురావడానికి మరియు ఈ స్థితిని నిర్వహించడానికి ఉపయోగించబడుతుంది.

నేను ఇప్పుడు ఐదు సంవత్సరాలుగా పప్పెట్‌తో పని చేస్తున్నాను. ఈ వచనం తప్పనిసరిగా అధికారిక డాక్యుమెంటేషన్ నుండి కీలకమైన అంశాల యొక్క అనువదించబడిన మరియు క్రమబద్ధీకరించబడిన సంకలనం, ఇది ప్రారంభకులకు పప్పెట్ యొక్క సారాంశాన్ని త్వరగా అర్థం చేసుకోవడానికి అనుమతిస్తుంది.

ప్రాథమిక సమాచారం

పప్పెట్ యొక్క ఆపరేటింగ్ సిస్టమ్ క్లయింట్-సర్వర్, అయినప్పటికీ ఇది పరిమిత కార్యాచరణతో సర్వర్‌లెస్ ఆపరేషన్‌కు మద్దతు ఇస్తుంది.

ఆపరేషన్ యొక్క పుల్ మోడల్ ఉపయోగించబడుతుంది: డిఫాల్ట్‌గా, ప్రతి అరగంటకు ఒకసారి, క్లయింట్లు కాన్ఫిగరేషన్ కోసం సర్వర్‌ని సంప్రదించి దానిని వర్తింపజేస్తారు. మీరు అన్సిబుల్‌తో పని చేసి ఉంటే, వారు వేరే పుష్ మోడల్‌ను ఉపయోగిస్తారు: నిర్వాహకుడు కాన్ఫిగరేషన్‌ను వర్తింపజేసే ప్రక్రియను ప్రారంభిస్తాడు, క్లయింట్లు తాము దేనినీ వర్తింపజేయరు.

నెట్‌వర్క్ కమ్యూనికేషన్ సమయంలో, రెండు-మార్గం TLS ఎన్‌క్రిప్షన్ ఉపయోగించబడుతుంది: సర్వర్ మరియు క్లయింట్ వారి స్వంత ప్రైవేట్ కీలు మరియు సంబంధిత ధృవపత్రాలను కలిగి ఉంటాయి. సాధారణంగా సర్వర్ క్లయింట్‌ల కోసం సర్టిఫికేట్‌లను జారీ చేస్తుంది, అయితే సూత్రప్రాయంగా బాహ్య CAను ఉపయోగించడం సాధ్యమవుతుంది.

మేనిఫెస్టోలకు పరిచయం

పప్పెట్ పరిభాషలో తోలుబొమ్మ సర్వర్‌కి కనెక్ట్ నోడ్స్ (నోడ్స్). నోడ్స్ కోసం కాన్ఫిగరేషన్ వ్రాయబడింది మేనిఫెస్టోలలో ప్రత్యేక ప్రోగ్రామింగ్ భాషలో - పప్పెట్ DSL.

పప్పెట్ DSL అనేది డిక్లరేటివ్ భాష. ఇది వ్యక్తిగత వనరుల ప్రకటనల రూపంలో నోడ్ యొక్క కావలసిన స్థితిని వివరిస్తుంది, ఉదాహరణకు:

ఫైల్ ఉంది మరియు ఇది నిర్దిష్ట కంటెంట్‌ను కలిగి ఉంది.
ప్యాకేజీ వ్యవస్థాపించబడింది.
సేవ ప్రారంభమైంది.

వనరులను పరస్పరం అనుసంధానించవచ్చు:

డిపెండెన్సీలు ఉన్నాయి, అవి వనరులను ఉపయోగించే క్రమాన్ని ప్రభావితం చేస్తాయి.
ఉదాహరణకు, "మొదట ప్యాకేజీని ఇన్‌స్టాల్ చేసి, ఆపై కాన్ఫిగరేషన్ ఫైల్‌ను సవరించండి, ఆపై సేవను ప్రారంభించండి."
నోటిఫికేషన్‌లు ఉన్నాయి - వనరు మారినట్లయితే, అది దానికి సభ్యత్వం పొందిన వనరులకు నోటిఫికేషన్‌లను పంపుతుంది.
ఉదాహరణకు, కాన్ఫిగరేషన్ ఫైల్ మారితే, మీరు స్వయంచాలకంగా సేవను పునఃప్రారంభించవచ్చు.

అదనంగా, పప్పెట్ DSL ఫంక్షన్‌లు మరియు వేరియబుల్స్‌తో పాటు షరతులతో కూడిన స్టేట్‌మెంట్‌లు మరియు సెలెక్టర్‌లను కలిగి ఉంటుంది. వివిధ టెంప్లేటింగ్ మెకానిజమ్‌లకు కూడా మద్దతు ఉంది - EPP మరియు ERB.

పప్పెట్ రూబీలో వ్రాయబడింది, కాబట్టి చాలా నిర్మాణాలు మరియు నిబంధనలు అక్కడ నుండి తీసుకోబడ్డాయి. రూబీ పప్పెట్‌ని విస్తరించడానికి మిమ్మల్ని అనుమతిస్తుంది - సంక్లిష్ట తర్కం, కొత్త రకాల వనరులు, విధులను జోడించండి.

పప్పెట్ రన్ అవుతున్నప్పుడు, సర్వర్‌లోని ప్రతి నిర్దిష్ట నోడ్ కోసం మానిఫెస్ట్‌లు డైరెక్టరీలో కంపైల్ చేయబడతాయి. డైరెక్టరీ విధులు, వేరియబుల్స్ మరియు షరతులతో కూడిన ప్రకటనల విస్తరణ విలువను లెక్కించిన తర్వాత వనరులు మరియు వాటి సంబంధాల జాబితా.

సింటాక్స్ మరియు కోడ్‌స్టైల్

అందించిన ఉదాహరణలు సరిపోకపోతే సింటాక్స్‌ను అర్థం చేసుకోవడంలో మీకు సహాయపడే అధికారిక డాక్యుమెంటేషన్‌లోని విభాగాలు ఇక్కడ ఉన్నాయి:

మానిఫెస్ట్ ఎలా ఉంటుందో ఇక్కడ ఒక ఉదాహరణ ఉంది:

# Комментарии пишутся, как и много где, после решётки.
#
# Описание конфигурации ноды начинается с ключевого слова node,
# за которым следует селектор ноды — хостнейм (с доменом или без)
# или регулярное выражение для хостнеймов, или ключевое слово default.
#
# После этого в фигурных скобках описывается собственно конфигурация ноды.
#
# Одна и та же нода может попасть под несколько селекторов. Про приоритет
# селекторов написано в статье про синтаксис описания нод.
node 'hostname', 'f.q.d.n', /regexp/ {
  # Конфигурация по сути является перечислением ресурсов и их параметров.
  #
  # У каждого ресурса есть тип и название.
  #
  # Внимание: не может быть двух ресурсов одного типа с одинаковыми названиями!
  #
  # Описание ресурса начинается с его типа. Тип пишется в нижнем регистре.
  # Про разные типы ресурсов написано ниже.
  #
  # После типа в фигурных скобках пишется название ресурса, потом двоеточие,
  # дальше идёт опциональное перечисление параметров ресурса и их значений.
  # Значения параметров указываются через т.н. hash rocket (=>).
  resource { 'title':
    param1 => value1,
    param2 => value2,
    param3 => value3,
  }
}

ఇండెంటేషన్ మరియు లైన్ బ్రేక్‌లు మానిఫెస్ట్‌లో అవసరమైన భాగం కాదు, కానీ సిఫార్సు చేయబడింది స్టైల్ గైడ్. సారాంశం:

రెండు-స్పేస్ ఇండెంట్‌లు, ట్యాబ్‌లు ఉపయోగించబడవు.
కర్లీ జంట కలుపులు ఖాళీతో వేరు చేయబడతాయి; కోలన్లు ఖాళీతో వేరు చేయబడవు.
ప్రతి పరామితి తర్వాత కామాలు, చివరిదానితో సహా. ప్రతి పరామితి ప్రత్యేక లైన్‌లో ఉంటుంది. పారామితులు మరియు ఒక పరామితి లేకుండా కేసుకు మినహాయింపు ఇవ్వబడింది: మీరు ఒక లైన్‌లో మరియు కామా లేకుండా వ్రాయవచ్చు (అంటే. resource { 'title': } и resource { 'title': param => value }).
పారామితులపై బాణాలు ఒకే స్థాయిలో ఉండాలి.
వనరుల సంబంధ బాణాలు వాటి ముందు వ్రాయబడ్డాయి.

pappetserverలో ఫైల్‌ల స్థానం

మరింత వివరణ కోసం, నేను "రూట్ డైరెక్టరీ" భావనను పరిచయం చేస్తాను. రూట్ డైరెక్టరీ అనేది నిర్దిష్ట నోడ్ కోసం పప్పెట్ కాన్ఫిగరేషన్‌ను కలిగి ఉన్న డైరెక్టరీ.

రూట్ డైరెక్టరీ పప్పెట్ వెర్షన్ మరియు ఉపయోగించిన పరిసరాలపై ఆధారపడి మారుతుంది. పర్యావరణాలు ప్రత్యేక డైరెక్టరీలలో నిల్వ చేయబడిన కాన్ఫిగరేషన్ యొక్క స్వతంత్ర సెట్లు. సాధారణంగా gitతో కలిపి ఉపయోగిస్తారు, ఈ సందర్భంలో పర్యావరణాలు git శాఖల నుండి సృష్టించబడతాయి. దీని ప్రకారం, ప్రతి నోడ్ ఒక వాతావరణంలో లేదా మరొకదానిలో ఉంది. ఇది నోడ్‌లోనే లేదా ENCలో కాన్ఫిగర్ చేయబడవచ్చు, దాని గురించి నేను తదుపరి వ్యాసంలో మాట్లాడుతాను.

మూడవ సంస్కరణలో ("పాత పప్పెట్") బేస్ డైరెక్టరీ /etc/puppet. పరిసరాలను ఉపయోగించడం ఐచ్ఛికం - ఉదాహరణకు, మేము వాటిని పాత పప్పెట్‌తో ఉపయోగించము. పరిసరాలను ఉపయోగించినట్లయితే, అవి సాధారణంగా నిల్వ చేయబడతాయి /etc/puppet/environments, రూట్ డైరెక్టరీ పర్యావరణ డైరెక్టరీ అవుతుంది. ఎన్విరాన్మెంట్లు ఉపయోగించకపోతే, రూట్ డైరెక్టరీ బేస్ డైరెక్టరీ అవుతుంది.
నాల్గవ వెర్షన్ ("కొత్త పప్పెట్") నుండి ప్రారంభించి, పరిసరాలను ఉపయోగించడం తప్పనిసరి అయ్యింది మరియు బేస్ డైరెక్టరీకి తరలించబడింది /etc/puppetlabs/code. దీని ప్రకారం, పర్యావరణాలు నిల్వ చేయబడతాయి /etc/puppetlabs/code/environments, రూట్ డైరెక్టరీ అనేది పర్యావరణ డైరెక్టరీ.

రూట్ డైరెక్టరీలో తప్పనిసరిగా సబ్ డైరెక్టరీ ఉండాలి manifests, ఇది నోడ్‌లను వివరించే ఒకటి లేదా అంతకంటే ఎక్కువ మానిఫెస్ట్‌లను కలిగి ఉంటుంది. అదనంగా, ఒక ఉప డైరెక్టరీ ఉండాలి modules, ఇది మాడ్యూల్‌లను కలిగి ఉంటుంది. మాడ్యూల్స్ ఏమిటో కొంచెం తరువాత నేను మీకు చెప్తాను. అదనంగా, పాత పప్పెట్‌కు ఉప డైరెక్టరీ కూడా ఉండవచ్చు files, ఇది మేము నోడ్‌లకు కాపీ చేసే వివిధ ఫైల్‌లను కలిగి ఉంటుంది. కొత్త పప్పెట్‌లో, అన్ని ఫైల్‌లు మాడ్యూల్స్‌లో ఉంచబడతాయి.

మానిఫెస్ట్ ఫైల్‌లు పొడిగింపును కలిగి ఉంటాయి .pp.

కొన్ని పోరాట ఉదాహరణలు

నోడ్ మరియు దానిపై వనరు యొక్క వివరణ

నోడ్ మీద server1.testdomain ఒక ఫైల్ సృష్టించబడాలి /etc/issue కంటెంట్ తో Debian GNU/Linux n l. ఫైల్ తప్పనిసరిగా వినియోగదారు మరియు సమూహం స్వంతం అయి ఉండాలి root, యాక్సెస్ హక్కులు తప్పనిసరిగా ఉండాలి 644.

మేము మానిఫెస్టోను వ్రాస్తాము:

node 'server1.testdomain' {   # блок конфигурации, относящийся к ноде server1.testdomain
    file { '/etc/issue':   # описываем файл /etc/issue
        ensure  => present,   # этот файл должен существовать
        content => 'Debian GNU/Linux n l',   # у него должно быть такое содержимое
        owner   => root,   # пользователь-владелец
        group   => root,   # группа-владелец
        mode    => '0644',   # права на файл. Они заданы в виде строки (в кавычках), потому что иначе число с 0 в начале будет воспринято как записанное в восьмеричной системе, и всё пойдёт не так, как задумано
    }
}

నోడ్‌లోని వనరుల మధ్య సంబంధాలు

నోడ్ మీద server2.testdomain nginx మునుపు సిద్ధం చేసిన కాన్ఫిగరేషన్‌తో పని చేస్తూ ఉండాలి.

సమస్యను విచ్ఛిన్నం చేద్దాం:

ప్యాకేజీని ఇన్‌స్టాల్ చేయాలి nginx.
కాన్ఫిగరేషన్ ఫైల్‌లు సర్వర్ నుండి కాపీ చేయబడటం అవసరం.
సేవ అమలులో ఉండాలి nginx.
కాన్ఫిగరేషన్ నవీకరించబడినట్లయితే, సేవ తప్పనిసరిగా పునఃప్రారంభించబడాలి.

మేము మానిఫెస్టోను వ్రాస్తాము:

node 'server2.testdomain' {   # блок конфигурации, относящийся к ноде server2.testdomain
    package { 'nginx':   # описываем пакет nginx
        ensure => installed,   # он должен быть установлен
    }
  # Прямая стрелка (->) говорит о том, что ресурс ниже должен
  # создаваться после ресурса, описанного выше.
  # Такие зависимости транзитивны.
    -> file { '/etc/nginx':   # описываем файл /etc/nginx
        ensure  => directory,   # это должна быть директория
        source  => 'puppet:///modules/example/nginx-conf',   # её содержимое нужно брать с паппет-сервера по указанному адресу
        recurse => true,   # копировать файлы рекурсивно
        purge   => true,   # нужно удалять лишние файлы (те, которых нет в источнике)
        force   => true,   # удалять лишние директории
    }
  # Волнистая стрелка (~>) говорит о том, что ресурс ниже должен
  # подписаться на изменения ресурса, описанного выше.
  # Волнистая стрелка включает в себя прямую (->).
    ~> service { 'nginx':   # описываем сервис nginx
        ensure => running,   # он должен быть запущен
        enable => true,   # его нужно запускать автоматически при старте системы
    }
  # Когда ресурс типа service получает уведомление,
  # соответствующий сервис перезапускается.
}

ఇది పని చేయడానికి, మీకు పప్పెట్ సర్వర్‌లో సుమారుగా కింది ఫైల్ స్థానం అవసరం:

/etc/puppetlabs/code/environments/production/ # (это для нового Паппета, для старого корневой директорией будет /etc/puppet)
├── manifests/
│   └── site.pp
└── modules/
    └── example/
        └── files/
            └── nginx-conf/
                ├── nginx.conf
                ├── mime.types
                └── conf.d/
                    └── some.conf

వనరుల రకాలు

మద్దతు ఉన్న వనరుల రకాల పూర్తి జాబితాను ఇక్కడ చూడవచ్చు డాక్యుమెంటేషన్‌లో, ఇక్కడ నేను ఐదు ప్రాథమిక రకాలను వివరిస్తాను, ఇది నా ఆచరణలో చాలా సమస్యలను పరిష్కరించడానికి సరిపోతుంది.

ఫైలు

ఫైల్‌లు, డైరెక్టరీలు, సిమ్‌లింక్‌లు, వాటి కంటెంట్‌లు మరియు యాక్సెస్ హక్కులను నిర్వహిస్తుంది.

ఎంపికలు:

వనరు పేరు - ఫైల్‌కి మార్గం (ఐచ్ఛికం)
మార్గం - ఫైల్‌కి మార్గం (ఇది పేరులో పేర్కొనబడకపోతే)
నిర్ధారించడానికి - ఫైల్ రకం:
- absent - ఫైల్‌ను తొలగించండి
- present — ఏదైనా రకమైన ఫైల్ ఉండాలి (ఫైల్ లేకపోతే, సాధారణ ఫైల్ సృష్టించబడుతుంది)
- file - సాధారణ ఫైల్
- directory - డైరెక్టరీ
- link - సిమ్లింక్
కంటెంట్ — ఫైల్ కంటెంట్‌లు (సాధారణ ఫైల్‌లకు మాత్రమే సరిపోతాయి, వీటితో కలిసి ఉపయోగించబడదు మూలం లేదా లక్ష్యం)
మూలం — మీరు ఫైల్ యొక్క కంటెంట్‌లను కాపీ చేయాలనుకుంటున్న మార్గానికి లింక్ (దీనితో కలిసి ఉపయోగించబడదు కంటెంట్ లేదా లక్ష్యం) పథకంతో URIగా పేర్కొనవచ్చు puppet: (అప్పుడు పప్పెట్ సర్వర్ నుండి ఫైల్‌లు ఉపయోగించబడతాయి), మరియు పథకంతో http: (ఈ సందర్భంలో ఏమి జరుగుతుందో స్పష్టంగా ఉందని నేను ఆశిస్తున్నాను), మరియు రేఖాచిత్రంతో కూడా file: లేదా స్కీమా లేకుండా సంపూర్ణ మార్గంగా (అప్పుడు నోడ్‌లోని స్థానిక FS నుండి ఫైల్ ఉపయోగించబడుతుంది)
లక్ష్యం — సిమ్‌లింక్ ఎక్కడ సూచించాలి (కలిసి ఉపయోగించబడదు కంటెంట్ లేదా మూలం)
యజమాని — ఫైల్‌ను కలిగి ఉండవలసిన వినియోగదారు
సమూహం — ఫైల్ చెందిన సమూహం
మోడ్ — ఫైల్ అనుమతులు (స్ట్రింగ్‌గా)
పునరావృతం - రికర్సివ్ డైరెక్టరీ ప్రాసెసింగ్‌ని ప్రారంభిస్తుంది
ప్రక్షాళనలో - పప్పెట్‌లో వివరించబడని ఫైల్‌లను తొలగించడాన్ని ప్రారంభిస్తుంది
ఫోర్స్ - పప్పెట్‌లో వివరించబడని డైరెక్టరీలను తొలగించడాన్ని ప్రారంభిస్తుంది

ప్యాకేజీ

ప్యాకేజీలను ఇన్‌స్టాల్ చేస్తుంది మరియు తీసివేస్తుంది. నోటిఫికేషన్‌లను నిర్వహించగల సామర్థ్యం - పరామితి పేర్కొనబడితే ప్యాకేజీని మళ్లీ ఇన్‌స్టాల్ చేస్తుంది reinstall_on_refresh.

ఎంపికలు:

వనరు పేరు - ప్యాకేజీ పేరు (ఐచ్ఛికం)
పేరు - ప్యాకేజీ పేరు (పేరులో పేర్కొనకపోతే)
ప్రొవైడర్ - ఉపయోగించడానికి ప్యాకేజీ మేనేజర్
నిర్ధారించడానికి - ప్యాకేజీ యొక్క కావలసిన స్థితి:
- present, installed - ఏదైనా వెర్షన్ ఇన్‌స్టాల్ చేయబడింది
- latest - తాజా వెర్షన్ ఇన్‌స్టాల్ చేయబడింది
- absent - తొలగించబడింది (apt-get remove)
- purged - కాన్ఫిగరేషన్ ఫైల్‌లతో పాటు తొలగించబడింది (apt-get purge)
- held - ప్యాకేజీ వెర్షన్ లాక్ చేయబడింది (apt-mark hold)
- любая другая строка - పేర్కొన్న సంస్కరణ వ్యవస్థాపించబడింది
reinstall_on_refresh - ఉంటే true, నోటిఫికేషన్ అందిన తర్వాత ప్యాకేజీ మళ్లీ ఇన్‌స్టాల్ చేయబడుతుంది. బిల్డ్ పారామితులను మార్చేటప్పుడు ప్యాకేజీలను పునర్నిర్మించడం అవసరమయ్యే సోర్స్-ఆధారిత పంపిణీలకు ఉపయోగపడుతుంది. డిఫాల్ట్ false.

సేవ

సేవలను నిర్వహిస్తుంది. నోటిఫికేషన్‌లను ప్రాసెస్ చేయగలదు - సేవను పునఃప్రారంభిస్తుంది.

ఎంపికలు:

వనరు పేరు - నిర్వహించాల్సిన సేవ (ఐచ్ఛికం)
పేరు - నిర్వహించాల్సిన సేవ (పేరులో పేర్కొనకపోతే)
నిర్ధారించడానికి - సేవ యొక్క కావలసిన స్థితి:
- running - ప్రారంభించబడింది
- stopped - ఆగిపోయింది
ఎనేబుల్ - సేవను ప్రారంభించే సామర్థ్యాన్ని నియంత్రిస్తుంది:
- true — ఆటోరన్ ప్రారంభించబడింది (systemctl enable)
- mask - మారువేషంలో (systemctl mask)
- false — ఆటోరన్ నిలిపివేయబడింది (systemctl disable)
పునఃప్రారంభమైన - సేవను పునఃప్రారంభించమని ఆదేశం
స్థితి — సేవ స్థితిని తనిఖీ చేయడానికి ఆదేశం
పునఃప్రారంభించండి — సర్వీస్ initscript పునఃప్రారంభించడాన్ని సపోర్ట్ చేస్తుందో లేదో సూచించండి. ఉంటే false మరియు పరామితి పేర్కొనబడింది పునఃప్రారంభమైన - ఈ పరామితి యొక్క విలువ ఉపయోగించబడుతుంది. ఉంటే false మరియు పరామితి పునఃప్రారంభమైన పేర్కొనబడలేదు - సేవ నిలిపివేయబడింది మరియు పునఃప్రారంభించడం ప్రారంభించబడింది (కానీ systemd ఆదేశాన్ని ఉపయోగిస్తుంది systemctl restart).
హోదా — సర్వీస్ initscript ఆదేశానికి మద్దతిస్తుందో లేదో సూచించండి status. ఉంటే false, అప్పుడు పరామితి విలువ ఉపయోగించబడుతుంది స్థితి. డిఫాల్ట్ true.

కార్యనిర్వాహకుడు

బాహ్య ఆదేశాలను అమలు చేస్తుంది. మీరు పారామితులను పేర్కొనకపోతే సృష్టిస్తుంది, అయితేనే, తప్ప లేదా రిఫ్రెష్‌గా, పప్పెట్ రన్ చేయబడిన ప్రతిసారీ కమాండ్ అమలు చేయబడుతుంది. నోటిఫికేషన్‌లను ప్రాసెస్ చేయగలదు - ఆదేశాన్ని అమలు చేస్తుంది.

ఎంపికలు:

వనరు పేరు - అమలు చేయవలసిన ఆదేశం (ఐచ్ఛికం)
కమాండ్ - అమలు చేయవలసిన ఆదేశం (ఇది పేరులో పేర్కొనబడకపోతే)
మార్గం - ఎక్జిక్యూటబుల్ ఫైల్ కోసం చూసే మార్గాలు
అయితేనే — ఈ పారామీటర్‌లో పేర్కొన్న ఆదేశం సున్నా రిటర్న్ కోడ్‌తో పూర్తి చేయబడితే, ప్రధాన ఆదేశం అమలు చేయబడుతుంది
తప్ప — ఈ పరామితిలో పేర్కొన్న కమాండ్ సున్నా కాని రిటర్న్ కోడ్‌తో పూర్తి చేసినట్లయితే, ప్రధాన ఆదేశం అమలు చేయబడుతుంది
సృష్టిస్తుంది — ఈ పరామితిలో పేర్కొన్న ఫైల్ ఉనికిలో లేకుంటే, ప్రధాన ఆదేశం అమలు చేయబడుతుంది
రిఫ్రెష్‌గా - ఉంటే true, ఈ కార్యనిర్వాహకుడు ఇతర వనరుల నుండి నోటిఫికేషన్‌ను స్వీకరించినప్పుడు మాత్రమే ఆదేశం అమలు చేయబడుతుంది
cwd — ఆదేశాన్ని అమలు చేసే డైరెక్టరీ
యూజర్ — ఆదేశాన్ని అమలు చేసే వినియోగదారు
ప్రొవైడర్ - ఆదేశాన్ని ఎలా అమలు చేయాలి:
- POSIX — పిల్లల ప్రక్రియ కేవలం సృష్టించబడింది, ఖచ్చితంగా పేర్కొనండి మార్గం
- షెల్ — ఆదేశం షెల్‌లో ప్రారంభించబడింది /bin/sh, పేర్కొనబడకపోవచ్చు మార్గం, మీరు గ్లోబింగ్, పైపులు మరియు ఇతర షెల్ లక్షణాలను ఉపయోగించవచ్చు. ఏదైనా ప్రత్యేక అక్షరాలు ఉంటే సాధారణంగా స్వయంచాలకంగా గుర్తించబడుతుంది (|, ;, &&, || మొదలైనవి).

క్రాన్

క్రోన్‌జాబ్‌లను నియంత్రిస్తుంది.

ఎంపికలు:

వనరు పేరు - కేవలం ఒక రకమైన ఐడెంటిఫైయర్
నిర్ధారించడానికి - క్రౌన్‌జాబ్ స్టేట్:
- present - ఉనికిలో లేనట్లయితే సృష్టించండి
- absent - ఉన్నట్లయితే తొలగించండి
కమాండ్ - ఏ ఆదేశాన్ని అమలు చేయాలి
వాతావరణంలో — ఏ వాతావరణంలో ఆదేశాన్ని అమలు చేయాలి (పర్యావరణ వేరియబుల్స్ మరియు వాటి విలువల జాబితా ద్వారా =)
యూజర్ — ఆదేశాన్ని ఏ వినియోగదారు నుండి అమలు చేయాలి
నిమిషం, గంట, వారపు రోజు, నెల, నెలరోజు - క్రాన్ ఎప్పుడు అమలు చేయాలి. ఈ లక్షణాలలో ఏవైనా పేర్కొనబడకపోతే, క్రాంటాబ్‌లో దాని విలువ ఉంటుంది *.

పప్పెట్ 6.0లో క్రాన్ లాగా పెట్టె నుండి తీసివేయబడింది puppetserverలో, సాధారణ సైట్‌లో డాక్యుమెంటేషన్ లేదు. కానీ అతడు పెట్టెలో ఉంది పప్పెట్-ఏజెంట్‌లో, దానిని విడిగా ఇన్‌స్టాల్ చేయవలసిన అవసరం లేదు. మీరు దానికి సంబంధించిన డాక్యుమెంటేషన్‌ని చూడవచ్చు పప్పెట్ యొక్క ఐదవ వెర్షన్ కోసం డాక్యుమెంటేషన్‌లో, లేదా GitHubలో.

సాధారణంగా వనరుల గురించి

వనరుల ప్రత్యేకత కోసం అవసరాలు

మనం ఎదుర్కొనే అత్యంత సాధారణ తప్పు డూప్లికేట్ డిక్లరేషన్. డైరెక్టరీలో ఒకే పేరుతో ఒకే రకమైన రెండు లేదా అంతకంటే ఎక్కువ వనరులు కనిపించినప్పుడు ఈ లోపం సంభవిస్తుంది.

కాబట్టి, నేను మళ్ళీ వ్రాస్తాను: ఒకే నోడ్‌కు సంబంధించిన మానిఫెస్ట్‌లు ఒకే శీర్షికతో ఒకే రకమైన వనరులను కలిగి ఉండకూడదు!

కొన్నిసార్లు అదే పేరుతో ప్యాకేజీలను ఇన్‌స్టాల్ చేయాల్సిన అవసరం ఉంది, కానీ వేర్వేరు ప్యాకేజీ నిర్వాహకులతో. ఈ సందర్భంలో, మీరు పరామితిని ఉపయోగించాలి nameలోపాన్ని నివారించడానికి:

package { 'ruby-mysql':
  ensure   => installed,
  name     => 'mysql',
  provider => 'gem',
}
package { 'python-mysql':
  ensure   => installed,
  name     => 'mysql',
  provider => 'pip',
}

ఇతర వనరుల రకాలు నకిలీని నివారించడంలో సహాయపడటానికి ఒకే విధమైన ఎంపికలను కలిగి ఉంటాయి - name у సేవ, command у కార్యనిర్వాహకుడు, మరియు మొదలైనవి.

మెటాపారామీటర్లు

ప్రతి వనరు రకం దాని స్వభావంతో సంబంధం లేకుండా కొన్ని ప్రత్యేక పారామితులను కలిగి ఉంటుంది.

మెటా పారామితుల పూర్తి జాబితా పప్పెట్ డాక్యుమెంటేషన్‌లో.

చిన్న జాబితా:

అవసరం — ఈ పరామితి ఈ వనరు ఏ వనరులపై ఆధారపడి ఉంటుందో సూచిస్తుంది.
ముందు - ఈ పరామితి ఈ వనరుపై ఆధారపడిన వనరులను నిర్దేశిస్తుంది.
చందా — ఈ పరామితి ఈ వనరు ఏ వనరుల నుండి నోటిఫికేషన్‌లను స్వీకరిస్తుందో నిర్దేశిస్తుంది.
తెలియజేయాలి — ఈ పరామితి ఈ వనరు నుండి నోటిఫికేషన్‌లను స్వీకరించే వనరులను నిర్దేశిస్తుంది.

జాబితా చేయబడిన అన్ని మెటాపారామీటర్‌లు ఒకే వనరు లింక్ లేదా స్క్వేర్ బ్రాకెట్‌లలోని లింక్‌ల శ్రేణిని అంగీకరిస్తాయి.

వనరులకు లింక్‌లు

రిసోర్స్ లింక్ అనేది వనరు యొక్క ప్రస్తావన. అవి ప్రధానంగా డిపెండెన్సీలను సూచించడానికి ఉపయోగించబడతాయి. ఉనికిలో లేని వనరును సూచించడం వలన సంకలన లోపం ఏర్పడుతుంది.

లింక్ యొక్క వాక్యనిర్మాణం క్రింది విధంగా ఉంది: మూలధన అక్షరంతో వనరు రకం (రకం పేరు డబుల్ కోలన్‌లను కలిగి ఉంటే, కోలన్‌ల మధ్య పేరులోని ప్రతి భాగం క్యాపిటలైజ్ చేయబడుతుంది), ఆపై చదరపు బ్రాకెట్‌లలో వనరు పేరు (పేరు కేసు మారదు!). ఖాళీలు ఉండకూడదు; రకం పేరు తర్వాత వెంటనే చదరపు బ్రాకెట్లు వ్రాయబడతాయి.

ఉదాహరణకు:

file { '/file1': ensure => present }
file { '/file2':
  ensure => directory,
  before => File['/file1'],
}
file { '/file3': ensure => absent }
File['/file1'] -> File['/file3']

డిపెండెన్సీలు మరియు నోటిఫికేషన్‌లు

డాక్యుమెంటేషన్ ఇక్కడ.

ఇంతకు ముందు చెప్పినట్లుగా, వనరుల మధ్య సాధారణ డిపెండెన్సీలు ట్రాన్సిటివ్. మార్గం ద్వారా, డిపెండెన్సీలను జోడించేటప్పుడు జాగ్రత్తగా ఉండండి - మీరు చక్రీయ డిపెండెన్సీలను సృష్టించవచ్చు, ఇది కంపైలేషన్ లోపానికి కారణమవుతుంది.

డిపెండెన్సీల వలె కాకుండా, నోటిఫికేషన్‌లు ట్రాన్సిటివ్ కాదు. నోటిఫికేషన్ కోసం క్రింది నియమాలు వర్తిస్తాయి:

వనరు నోటిఫికేషన్‌ను స్వీకరించినట్లయితే, అది నవీకరించబడుతుంది. నవీకరణ చర్యలు వనరు రకంపై ఆధారపడి ఉంటాయి - కార్యనిర్వాహకుడు ఆదేశాన్ని అమలు చేస్తుంది, సేవ సేవను పునఃప్రారంభిస్తుంది, ప్యాకేజీ ప్యాకేజీని మళ్లీ ఇన్‌స్టాల్ చేస్తుంది. రిసోర్స్‌లో అప్‌డేట్ చర్య నిర్వచించకపోతే, ఏమీ జరగదు.
పప్పెట్ యొక్క ఒక పరుగు సమయంలో, వనరు ఒకటి కంటే ఎక్కువసార్లు నవీకరించబడదు. నోటిఫికేషన్‌లలో డిపెండెన్సీలు ఉంటాయి మరియు డిపెండెన్సీ గ్రాఫ్ సైకిల్‌లను కలిగి ఉండనందున ఇది సాధ్యమవుతుంది.
పప్పెట్ వనరు యొక్క స్థితిని మార్చినట్లయితే, వనరు దానికి సభ్యత్వం పొందిన అన్ని వనరులకు నోటిఫికేషన్‌లను పంపుతుంది.
ఒక వనరు నవీకరించబడినట్లయితే, దానికి సభ్యత్వం పొందిన అన్ని వనరులకు అది నోటిఫికేషన్‌లను పంపుతుంది.

పేర్కొనబడని పారామితులను నిర్వహించడం

నియమం ప్రకారం, కొన్ని వనరుల పరామితి డిఫాల్ట్ విలువను కలిగి ఉండకపోతే మరియు మానిఫెస్ట్‌లో ఈ పరామితి పేర్కొనబడకపోతే, నోడ్‌లోని సంబంధిత వనరు కోసం పప్పెట్ ఈ లక్షణాన్ని మార్చదు. ఉదాహరణకు, రకం వనరు అయితే ఫైలు పరామితి పేర్కొనబడలేదు owner, అప్పుడు పప్పెట్ సంబంధిత ఫైల్ యజమానిని మార్చదు.

తరగతులు, వేరియబుల్స్ మరియు నిర్వచనాలకు పరిచయం

కాన్ఫిగరేషన్‌లో ఒకే భాగాన్ని కలిగి ఉన్న అనేక నోడ్‌లు ఉన్నాయని అనుకుందాం, కానీ తేడాలు కూడా ఉన్నాయి - లేకుంటే మనం అన్నింటినీ ఒకే బ్లాక్‌లో వివరించవచ్చు. node {}. వాస్తవానికి, మీరు కాన్ఫిగరేషన్ యొక్క సారూప్య భాగాలను కాపీ చేయవచ్చు, కానీ సాధారణంగా ఇది చెడ్డ పరిష్కారం - కాన్ఫిగరేషన్ పెరుగుతుంది మరియు మీరు కాన్ఫిగరేషన్ యొక్క సాధారణ భాగాన్ని మార్చినట్లయితే, మీరు చాలా ప్రదేశాలలో అదే విషయాన్ని సవరించాలి. అదే సమయంలో, పొరపాటు చేయడం సులభం, మరియు సాధారణంగా, DRY (మీరే పునరావృతం చేయవద్దు) సూత్రం ఒక కారణం కోసం కనుగొనబడింది.

ఈ సమస్యను పరిష్కరించడానికి అటువంటి డిజైన్ ఉంది తరగతి.

తరగతుల

Класс పాప్పెట్ కోడ్ యొక్క పేరు పెట్టబడిన బ్లాక్. కోడ్‌ని మళ్లీ ఉపయోగించడానికి తరగతులు అవసరం.

మొదట తరగతిని వివరించాలి. వివరణ కూడా ఎక్కడా ఎటువంటి వనరులను జోడించదు. తరగతి మానిఫెస్ట్‌లలో వివరించబడింది:

# Описание класса начинается с ключевого слова class и его названия.
# Дальше идёт тело класса в фигурных скобках.
class example_class {
    ...
}

దీని తరువాత, తరగతిని ఉపయోగించవచ్చు:

# первый вариант использования — в стиле ресурса с типом class
class { 'example_class': }
# второй вариант использования — с помощью функции include
include example_class
# про отличие этих двух вариантов будет рассказано дальше

మునుపటి టాస్క్ నుండి ఒక ఉదాహరణ - nginx యొక్క ఇన్‌స్టాలేషన్ మరియు కాన్ఫిగరేషన్‌ను తరగతిలోకి తరలిద్దాం:

class nginx_example {
    package { 'nginx':
        ensure => installed,
    }
    -> file { '/etc/nginx':
        ensure => directory,
        source => 'puppet:///modules/example/nginx-conf',
        recure => true,
        purge  => true,
        force  => true,
    }
    ~> service { 'nginx':
        ensure => running,
        enable => true,
    }
}

node 'server2.testdomain' {
    include nginx_example
}

వేరియబుల్స్

మునుపటి ఉదాహరణ నుండి తరగతి అన్నింటికీ అనువైనది కాదు ఎందుకంటే ఇది ఎల్లప్పుడూ ఒకే nginx కాన్ఫిగరేషన్‌ను తెస్తుంది. కాన్ఫిగరేషన్ వేరియబుల్‌కు మార్గాన్ని చేద్దాం, అప్పుడు ఈ తరగతి ఏదైనా కాన్ఫిగరేషన్‌తో nginxని ఇన్‌స్టాల్ చేయడానికి ఉపయోగించవచ్చు.

ఇది చేయవచ్చు వేరియబుల్స్ ఉపయోగించి.

శ్రద్ధ: పప్పెట్‌లోని వేరియబుల్స్ మార్పులేనివి!

అదనంగా, వేరియబుల్ ప్రకటించబడిన తర్వాత మాత్రమే యాక్సెస్ చేయబడుతుంది, లేకపోతే వేరియబుల్ విలువ undef.

వేరియబుల్స్‌తో పని చేయడానికి ఉదాహరణ:

# создание переменных
$variable = 'value'
$var2 = 1
$var3 = true
$var4 = undef
# использование переменных
$var5 = $var6
file { '/tmp/text': content => $variable }
# интерполяция переменных — раскрытие значения переменных в строках. Работает только в двойных кавычках!
$var6 = "Variable with name variable has value ${variable}"

తోలుబొమ్మ ఉంది నేమ్‌స్పేస్‌లు, మరియు వేరియబుల్స్, తదనుగుణంగా, కలిగి ఉంటాయి దృశ్యమానత ప్రాంతం: ఒకే పేరుతో ఉన్న వేరియబుల్‌ను వేర్వేరు నేమ్‌స్పేస్‌లలో నిర్వచించవచ్చు. వేరియబుల్ విలువను పరిష్కరిస్తున్నప్పుడు, వేరియబుల్ ప్రస్తుత నేమ్‌స్పేస్‌లో శోధించబడుతుంది, ఆపై జతచేసిన నేమ్‌స్పేస్‌లో మరియు మొదలైనవి.

నేమ్‌స్పేస్ ఉదాహరణలు:

గ్లోబల్ - క్లాస్ వెలుపల వేరియబుల్స్ లేదా నోడ్ వివరణ అక్కడికి వెళ్తుంది;
నోడ్ వివరణలో నోడ్ నేమ్‌స్పేస్;
తరగతి వివరణలో తరగతి నేమ్‌స్పేస్.

వేరియబుల్‌ను యాక్సెస్ చేసేటప్పుడు అస్పష్టతను నివారించడానికి, మీరు వేరియబుల్ పేరులో నేమ్‌స్పేస్‌ను పేర్కొనవచ్చు:

# переменная без пространства имён
$var
# переменная в глобальном пространстве имён
$::var
# переменная в пространстве имён класса
$classname::var
$::classname::var

nginx కాన్ఫిగరేషన్‌కు మార్గం వేరియబుల్‌లో ఉందని అంగీకరిస్తాం $nginx_conf_source. అప్పుడు తరగతి ఇలా కనిపిస్తుంది:

class nginx_example {
    package { 'nginx':
        ensure => installed,
    }
    -> file { '/etc/nginx':
        ensure => directory,
        source => $nginx_conf_source,   # здесь используем переменную вместо фиксированной строки
        recure => true,
        purge  => true,
        force  => true,
    }
    ~> service { 'nginx':
        ensure => running,
        enable => true,
    }
}

node 'server2.testdomain' {
    $nginx_conf_source = 'puppet:///modules/example/nginx-conf'
    include nginx_example
}

అయితే, ఇచ్చిన ఉదాహరణ చెడ్డది ఎందుకంటే క్లాస్‌లో ఎక్కడో ఒక వేరియబుల్ అటువంటి మరియు అటువంటి పేరుతో ఉపయోగించబడే "రహస్య జ్ఞానం" ఉంది. ఈ జ్ఞానాన్ని సాధారణం చేయడం చాలా సరైనది - తరగతులు పారామితులను కలిగి ఉంటాయి.

తరగతి పారామితులు క్లాస్ నేమ్‌స్పేస్‌లోని వేరియబుల్స్, అవి క్లాస్ హెడర్‌లో పేర్కొనబడ్డాయి మరియు క్లాస్ బాడీలో సాధారణ వేరియబుల్స్ వలె ఉపయోగించవచ్చు. మానిఫెస్ట్‌లో క్లాస్‌ని ఉపయోగిస్తున్నప్పుడు పారామీటర్ విలువలు పేర్కొనబడతాయి.

పరామితిని డిఫాల్ట్ విలువకు సెట్ చేయవచ్చు. ఒక పరామితి డిఫాల్ట్ విలువను కలిగి ఉండకపోతే మరియు ఉపయోగించినప్పుడు విలువ సెట్ చేయబడకపోతే, అది కంపైలేషన్ లోపానికి కారణమవుతుంది.

పై ఉదాహరణ నుండి తరగతిని పారామితి చేద్దాం మరియు రెండు పారామితులను జోడిద్దాం: మొదటిది, అవసరమైనది, కాన్ఫిగరేషన్‌కు మార్గం, మరియు రెండవది, ఐచ్ఛికం, nginxతో ప్యాకేజీ పేరు (డెబియన్‌లో, ఉదాహరణకు, ప్యాకేజీలు ఉన్నాయి. nginx, nginx-light, nginx-full).

# переменные описываются сразу после имени класса в круглых скобках
class nginx_example (
  $conf_source,
  $package_name = 'nginx-light', # параметр со значением по умолчанию
) {
  package { $package_name:
    ensure => installed,
  }
  -> file { '/etc/nginx':
    ensure  => directory,
    source  => $conf_source,
    recurse => true,
    purge   => true,
    force   => true,
  }
  ~> service { 'nginx':
    ensure => running,
    enable => true,
  }
}

node 'server2.testdomain' {
  # если мы хотим задать параметры класса, функция include не подойдёт* — нужно использовать resource-style declaration
  # *на самом деле подойдёт, но про это расскажу в следующей серии. Ключевое слово "Hiera".
  class { 'nginx_example':
    conf_source => 'puppet:///modules/example/nginx-conf',   # задаём параметры класса точно так же, как параметры для других ресурсов
  }
}

పప్పెట్‌లో, వేరియబుల్స్ టైప్ చేయబడతాయి. తినండి అనేక డేటా రకాలు. తరగతులు మరియు నిర్వచనాలకు పంపబడిన పారామీటర్ విలువలను ధృవీకరించడానికి డేటా రకాలు సాధారణంగా ఉపయోగించబడతాయి. ఆమోదించబడిన పరామితి పేర్కొన్న రకంతో సరిపోలకపోతే, సంకలన లోపం ఏర్పడుతుంది.

పరామితి పేరుకు ముందు టైప్ వెంటనే వ్రాయబడుతుంది:

class example (
  String $param1,
  Integer $param2,
  Array $param3,
  Hash $param4,
  Hash[String, String] $param5,
) {
  ...
}

తరగతులు: తరగతి పేరు vs తరగతి{'తరగతి పేరు':}

ప్రతి తరగతి ఒక రకమైన వనరు తరగతి. ఏ ఇతర రకమైన వనరు మాదిరిగానే, ఒకే నోడ్‌లో ఒకే తరగతికి చెందిన రెండు సందర్భాలు ఉండకూడదు.

మీరు రెండుసార్లు ఉపయోగించి ఒకే నోడ్‌కి తరగతిని జోడించడానికి ప్రయత్నిస్తే class { 'classname':} (భిన్నమైన లేదా ఒకే విధమైన పారామితులతో తేడా లేకుండా), సంకలన లోపం ఉంటుంది. కానీ మీరు వనరుల శైలిలో తరగతిని ఉపయోగిస్తే, మీరు వెంటనే మానిఫెస్ట్‌లో దాని అన్ని పారామితులను స్పష్టంగా సెట్ చేయవచ్చు.

అయితే, మీరు ఉపయోగిస్తే include, ఆపై తరగతిని కావలసినన్ని సార్లు జోడించవచ్చు. వాస్తవం ఏమిటంటే include డైరెక్టరీకి క్లాస్ జోడించబడిందో లేదో తనిఖీ చేసే ఒక idempotent ఫంక్షన్. తరగతి డైరెక్టరీలో లేకుంటే, అది దానిని జోడిస్తుంది మరియు అది ఇప్పటికే ఉన్నట్లయితే, అది ఏమీ చేయదు. కానీ ఉపయోగించే విషయంలో include మీరు క్లాస్ డిక్లరేషన్ సమయంలో తరగతి పారామితులను సెట్ చేయలేరు - అవసరమైన అన్ని పారామీటర్‌లు తప్పనిసరిగా బాహ్య డేటా సోర్స్‌లో సెట్ చేయబడాలి - Hiera లేదా ENC. మేము వాటిని గురించి తదుపరి వ్యాసంలో మాట్లాడుతాము.

నిర్వచిస్తుంది

మునుపటి బ్లాక్‌లో చెప్పినట్లు, ఒకే తరగతి నోడ్‌లో ఒకటి కంటే ఎక్కువసార్లు ఉండకూడదు. అయితే, కొన్ని సందర్భాల్లో మీరు ఒకే నోడ్‌లో వేర్వేరు పారామితులతో ఒకే బ్లాక్ కోడ్‌ని ఉపయోగించగలగాలి. మరో మాటలో చెప్పాలంటే, దాని స్వంత వనరు రకం అవసరం.

ఉదాహరణకు, PHP మాడ్యూల్‌ను ఇన్‌స్టాల్ చేయడానికి, మేము Avitoలో ఈ క్రింది వాటిని చేస్తాము:

ఈ మాడ్యూల్‌తో ప్యాకేజీని ఇన్‌స్టాల్ చేయండి.
ఈ మాడ్యూల్ కోసం కాన్ఫిగరేషన్ ఫైల్‌ని క్రియేట్ చేద్దాం.
మేము php-fpm కోసం configకి సిమ్‌లింక్‌ని సృష్టిస్తాము.
మేము php cli కోసం కాన్ఫిగరేషన్‌కు సిమ్‌లింక్‌ని సృష్టిస్తాము.

అటువంటి సందర్భాలలో, వంటి డిజైన్ నిర్వచించండి (నిర్వచించండి, నిర్వచించిన రకం, నిర్వచించబడిన వనరు రకం). A Define అనేది ఒక తరగతికి సారూప్యంగా ఉంటుంది, కానీ తేడాలు ఉన్నాయి: మొదటిది, ప్రతి Define అనేది ఒక వనరు రకం, ఒక వనరు కాదు; రెండవది, ప్రతి నిర్వచనానికి ఒక అవ్యక్త పరామితి ఉంటుంది $title, రిసోర్స్ పేరు ప్రకటించబడినప్పుడు ఎక్కడికి వెళుతుంది. తరగతుల విషయంలో వలె, ముందుగా ఒక నిర్వచనం వివరించబడాలి, ఆ తర్వాత దానిని ఉపయోగించవచ్చు.

PHP కోసం మాడ్యూల్‌తో సరళీకృత ఉదాహరణ:

define php74::module (
  $php_module_name = $title,
  $php_package_name = "php7.4-${title}",
  $version = 'installed',
  $priority = '20',
  $data = "extension=${title}.son",
  $php_module_path = '/etc/php/7.4/mods-available',
) {
  package { $php_package_name:
    ensure          => $version,
    install_options => ['-o', 'DPkg::NoTriggers=true'],  # триггеры дебиановских php-пакетов сами создают симлинки и перезапускают сервис php-fpm - нам это не нужно, так как и симлинками, и сервисом мы управляем с помощью Puppet
  }
  -> file { "${php_module_path}/${php_module_name}.ini":
    ensure  => $ensure,
    content => $data,
  }
  file { "/etc/php/7.4/cli/conf.d/${priority}-${php_module_name}.ini":
    ensure  => link,
    target  => "${php_module_path}/${php_module_name}.ini",
  }
  file { "/etc/php/7.4/fpm/conf.d/${priority}-${php_module_name}.ini":
    ensure  => link,
    target  => "${php_module_path}/${php_module_name}.ini",
  }
}

node server3.testdomain {
  php74::module { 'sqlite3': }
  php74::module { 'amqp': php_package_name => 'php-amqp' }
  php74::module { 'msgpack': priority => '10' }
}

డూప్లికేట్ డిక్లరేషన్ ఎర్రర్‌ను క్యాచ్ చేయడానికి సులభమైన మార్గం డిఫైన్‌లో ఉంది. ఒక నిర్వచనం స్థిరమైన పేరుతో వనరును కలిగి ఉంటే మరియు కొన్ని నోడ్‌లో ఈ నిర్వచనం యొక్క రెండు లేదా అంతకంటే ఎక్కువ ఉదాహరణలు ఉంటే ఇది జరుగుతుంది.

దీని నుండి మిమ్మల్ని మీరు రక్షించుకోవడం చాలా సులభం: నిర్వచనం లోపల ఉన్న అన్ని వనరులను బట్టి తప్పనిసరిగా పేరు ఉండాలి $title. ప్రత్యామ్నాయం అనేది వనరులను అసంపూర్తిగా చేర్చడం; సరళమైన సందర్భంలో, నిర్వచనం యొక్క అన్ని సందర్భాలకు సాధారణమైన వనరులను ప్రత్యేక తరగతికి తరలించడం మరియు ఈ తరగతిని నిర్వచనం - ఫంక్షన్‌లో చేర్చడం సరిపోతుంది. include బుద్ధిహీనుడు.

రిసోర్స్‌లను జోడించేటప్పుడు ఐడెంపోటెన్సీని సాధించడానికి ఇతర మార్గాలు ఉన్నాయి, అవి ఫంక్షన్‌లను ఉపయోగించడం defined и ensure_resources, కానీ నేను దాని గురించి తదుపరి ఎపిసోడ్‌లో మీకు చెప్తాను.

తరగతులు మరియు నిర్వచనాల కోసం డిపెండెన్సీలు మరియు నోటిఫికేషన్‌లు

తరగతులు మరియు నిర్వచనాలు డిపెండెన్సీలు మరియు నోటిఫికేషన్‌లను నిర్వహించడానికి క్రింది నియమాలను జోడిస్తాయి:

క్లాస్/డిఫైన్‌పై డిపెండెన్సీ అనేది క్లాస్/డిఫైన్ యొక్క అన్ని వనరులపై డిపెండెన్సీలను జోడిస్తుంది;
ఒక క్లాస్/డిఫైన్ డిపెండెన్సీ అన్ని క్లాస్‌లకు డిపెండెన్సీలను జోడిస్తుంది/వనరులను నిర్వచిస్తుంది;
క్లాస్/డిఫైన్ నోటిఫికేషన్ క్లాస్ యొక్క అన్ని వనరులను తెలియజేస్తుంది/నిర్వచిస్తుంది;
క్లాస్/డిఫైన్ సబ్‌స్క్రిప్షన్ క్లాస్ యొక్క అన్ని వనరులకు సబ్‌స్క్రైబ్ చేస్తుంది/నిర్వచించండి.

షరతులతో కూడిన ప్రకటనలు మరియు ఎంపికదారులు

డాక్యుమెంటేషన్ ఇక్కడ.

if

ఇది ఇక్కడ సులభం:

if ВЫРАЖЕНИЕ1 {
  ...
} elsif ВЫРАЖЕНИЕ2 {
  ...
} else {
  ...
}

తప్ప

ఒకవేళ రివర్స్‌లో ఉంటే తప్ప: వ్యక్తీకరణ తప్పు అయితే కోడ్ యొక్క బ్లాక్ అమలు చేయబడుతుంది.

unless ВЫРАЖЕНИЕ {
  ...
}

కేసు

ఇక్కడ కూడా సంక్లిష్టంగా ఏమీ లేదు. మీరు సాధారణ విలువలు (తీగలు, సంఖ్యలు మొదలైనవి), సాధారణ వ్యక్తీకరణలు మరియు డేటా రకాలను విలువలుగా ఉపయోగించవచ్చు.

case ВЫРАЖЕНИЕ {
  ЗНАЧЕНИЕ1: { ... }
  ЗНАЧЕНИЕ2, ЗНАЧЕНИЕ3: { ... }
  default: { ... }
}

సెలెక్టర్లు

సెలెక్టర్ అనేది ఇలాంటి భాష నిర్మాణం case, కానీ కోడ్ బ్లాక్‌ని అమలు చేయడానికి బదులుగా, అది విలువను అందిస్తుంది.

$var = $othervar ? { 'val1' => 1, 'val2' => 2, default => 3 }

గుణకాలు

కాన్ఫిగరేషన్ చిన్నగా ఉన్నప్పుడు, దానిని సులభంగా ఒక మానిఫెస్ట్‌లో ఉంచవచ్చు. కానీ మనం వివరించే మరిన్ని కాన్ఫిగరేషన్‌లు, మానిఫెస్ట్‌లో ఎక్కువ తరగతులు మరియు నోడ్‌లు ఉన్నాయి, అది పెరుగుతుంది మరియు దానితో పని చేయడం అసౌకర్యంగా మారుతుంది.

అదనంగా, కోడ్ పునర్వినియోగ సమస్య ఉంది - అన్ని కోడ్‌లు ఒకే మానిఫెస్ట్‌లో ఉన్నప్పుడు, ఈ కోడ్‌ని ఇతరులతో భాగస్వామ్యం చేయడం కష్టం. ఈ రెండు సమస్యలను పరిష్కరించడానికి, పప్పెట్‌కు మాడ్యూల్స్ అనే ఎంటిటీ ఉంది.

గుణకాలు - ఇవి ప్రత్యేక డైరెక్టరీలో ఉంచబడిన తరగతులు, నిర్వచనాలు మరియు ఇతర పప్పెట్ ఎంటిటీల సెట్లు. మరో మాటలో చెప్పాలంటే, మాడ్యూల్ అనేది పప్పెట్ లాజిక్ యొక్క స్వతంత్ర భాగం. ఉదాహరణకు, nginxతో పని చేయడానికి ఒక మాడ్యూల్ ఉండవచ్చు మరియు అది nginxతో పని చేయడానికి అవసరమైన వాటిని మరియు మాత్రమే కలిగి ఉంటుంది లేదా PHPతో పని చేయడానికి మాడ్యూల్ ఉండవచ్చు మరియు మొదలైనవి ఉండవచ్చు.

మాడ్యూల్స్ వెర్షన్ చేయబడ్డాయి మరియు ఒకదానికొకటి మాడ్యూల్స్ యొక్క డిపెండెన్సీలకు కూడా మద్దతు ఉంది. మాడ్యూల్స్ యొక్క ఓపెన్ రిపోజిటరీ ఉంది - తోలుబొమ్మ ఫోర్జ్.

పప్పెట్ సర్వర్‌లో, మాడ్యూల్స్ రూట్ డైరెక్టరీ యొక్క మాడ్యూల్స్ సబ్ డైరెక్టరీలో ఉన్నాయి. ప్రతి మాడ్యూల్ లోపల ఒక ప్రామాణిక డైరెక్టరీ పథకం ఉంది - మానిఫెస్ట్‌లు, ఫైల్‌లు, టెంప్లేట్‌లు, లిబ్ మరియు మొదలైనవి.

మాడ్యూల్‌లో ఫైల్ నిర్మాణం

మాడ్యూల్ యొక్క రూట్ వివరణాత్మక పేర్లతో క్రింది డైరెక్టరీలను కలిగి ఉండవచ్చు:

manifests - ఇది మానిఫెస్టోలను కలిగి ఉంటుంది
files - ఇది ఫైళ్లను కలిగి ఉంటుంది
templates - ఇది టెంప్లేట్‌లను కలిగి ఉంటుంది
lib - ఇది రూబీ కోడ్‌ని కలిగి ఉంటుంది

ఇది డైరెక్టరీలు మరియు ఫైల్‌ల పూర్తి జాబితా కాదు, కానీ ప్రస్తుతానికి ఈ కథనానికి ఇది సరిపోతుంది.

మాడ్యూల్‌లోని వనరుల పేర్లు మరియు ఫైల్‌ల పేర్లు

డాక్యుమెంటేషన్ ఇక్కడ.

మాడ్యూల్‌లోని వనరులు (తరగతులు, నిర్వచనాలు) మీకు నచ్చిన పేరు పెట్టబడవు. అదనంగా, ఒక వనరు పేరు మరియు పప్పెట్ ఆ వనరు యొక్క వివరణ కోసం చూసే ఫైల్ పేరు మధ్య ప్రత్యక్ష అనురూప్యం ఉంది. మీరు నామకరణ నియమాలను ఉల్లంఘిస్తే, పప్పెట్ కేవలం వనరుల వివరణను కనుగొనదు మరియు మీరు సంకలన దోషాన్ని పొందుతారు.

నియమాలు సరళమైనవి:

మాడ్యూల్‌లోని అన్ని వనరులు తప్పనిసరిగా మాడ్యూల్ నేమ్‌స్పేస్‌లో ఉండాలి. మాడ్యూల్ అని పిలిస్తే foo, అప్పుడు దానిలోని అన్ని వనరులకు పేరు పెట్టాలి foo::<anything>, లేదా కేవలం foo.
మాడ్యూల్ పేరుతో ఉన్న వనరు తప్పనిసరిగా ఫైల్‌లో ఉండాలి init.pp.
ఇతర వనరుల కోసం, ఫైల్ పేరు పెట్టే పథకం క్రింది విధంగా ఉంటుంది:
- మాడ్యూల్ పేరుతో ఉన్న ఉపసర్గ విస్మరించబడింది
- అన్ని డబుల్ కోలన్‌లు, ఏదైనా ఉంటే, స్లాష్‌లతో భర్తీ చేయబడతాయి
- పొడిగింపు జోడించబడింది .pp

నేను ఒక ఉదాహరణతో ప్రదర్శిస్తాను. నేను మాడ్యూల్ రాస్తున్నాను అనుకుందాం nginx. ఇది క్రింది వనరులను కలిగి ఉంది:

తరగతి nginx మానిఫెస్ట్‌లో వివరించబడింది init.pp;
తరగతి nginx::service మానిఫెస్ట్‌లో వివరించబడింది service.pp;
నిర్వచించండి nginx::server మానిఫెస్ట్‌లో వివరించబడింది server.pp;
నిర్వచించండి nginx::server::location మానిఫెస్ట్‌లో వివరించబడింది server/location.pp.

పద్ధతులు

టెంప్లేట్‌లు ఏమిటో మీకు ఖచ్చితంగా తెలుసు; నేను వాటిని ఇక్కడ వివరంగా వివరించను. అయితే నేను దానిని వదిలేస్తాను వికీపీడియాకు లింక్.

టెంప్లేట్‌లను ఎలా ఉపయోగించాలి: టెంప్లేట్ యొక్క అర్థాన్ని ఫంక్షన్‌ని ఉపయోగించి విస్తరించవచ్చు template, ఇది టెంప్లేట్‌కు మార్గం ద్వారా పంపబడుతుంది. రకం వనరుల కోసం ఫైలు పరామితితో కలిసి ఉపయోగించబడుతుంది content. ఉదాహరణకు, ఇలా:

file { '/tmp/example': content => template('modulename/templatename.erb')

మార్గాన్ని వీక్షించండి <modulename>/<filename> ఫైల్‌ని సూచిస్తుంది <rootdir>/modules/<modulename>/templates/<filename>.

అదనంగా, ఒక ఫంక్షన్ ఉంది inline_template — ఇది టెంప్లేట్ టెక్స్ట్‌ను ఇన్‌పుట్‌గా స్వీకరిస్తుంది, ఫైల్ పేరు కాదు.

టెంప్లేట్‌లలో, మీరు ప్రస్తుత పరిధిలో ఉన్న అన్ని పప్పెట్ వేరియబుల్‌లను ఉపయోగించవచ్చు.

పప్పెట్ ERB మరియు EPP ఆకృతిలో టెంప్లేట్‌లకు మద్దతు ఇస్తుంది:

ERB గురించి క్లుప్తంగా

నియంత్రణ నిర్మాణాలు:

<%= ВЫРАЖЕНИЕ %> - వ్యక్తీకరణ విలువను చొప్పించండి
<% ВЫРАЖЕНИЕ %> — వ్యక్తీకరణ యొక్క విలువను లెక్కించండి (దానిని చొప్పించకుండా). షరతులతో కూడిన ప్రకటనలు (ఉంటే) మరియు లూప్‌లు (ప్రతి) సాధారణంగా ఇక్కడకు వెళ్తాయి.
<%# КОММЕНТАРИЙ %>

ERBలోని వ్యక్తీకరణలు రూబీలో వ్రాయబడ్డాయి (ERB నిజానికి ఎంబెడెడ్ రూబీ).

మానిఫెస్ట్ నుండి వేరియబుల్స్ యాక్సెస్ చేయడానికి, మీరు జోడించాలి @ వేరియబుల్ పేరుకు. నియంత్రణ నిర్మాణం తర్వాత కనిపించే లైన్ బ్రేక్‌ను తీసివేయడానికి, మీరు క్లోజింగ్ ట్యాగ్‌ని ఉపయోగించాలి -%>.

టెంప్లేట్ ఉపయోగించి ఉదాహరణ

జూకీపర్‌ని నియంత్రించడానికి నేను మాడ్యూల్‌ని వ్రాస్తున్నాను అనుకుందాం. కాన్ఫిగరేషన్ సృష్టించడానికి బాధ్యత వహించే తరగతి ఇలా కనిపిస్తుంది:

class zookeeper::configure (
  Array[String] $nodes,
  Integer $port_client,
  Integer $port_quorum,
  Integer $port_leader,
  Hash[String, Any] $properties,
  String $datadir,
) {
  file { '/etc/zookeeper/conf/zoo.cfg':
    ensure  => present,
    content => template('zookeeper/zoo.cfg.erb'),
  }
}

మరియు సంబంధిత టెంప్లేట్ zoo.cfg.erb - కాబట్టి:

<% if @nodes.length > 0 -%>
<% @nodes.each do |node, id| -%>
server.<%= id %>=<%= node %>:<%= @port_leader %>:<%= @port_quorum %>;<%= @port_client %>
<% end -%>
<% end -%>

dataDir=<%= @datadir %>

<% @properties.each do |k, v| -%>
<%= k %>=<%= v %>
<% end -%>

వాస్తవాలు మరియు అంతర్నిర్మిత వేరియబుల్స్

తరచుగా కాన్ఫిగరేషన్ యొక్క నిర్దిష్ట భాగం ప్రస్తుతం నోడ్‌లో ఏమి జరుగుతుందో దానిపై ఆధారపడి ఉంటుంది. ఉదాహరణకు, డెబియన్ విడుదల అంటే ఏమిటో ఆధారపడి, మీరు ప్యాకేజీ యొక్క ఒకటి లేదా మరొక సంస్కరణను ఇన్‌స్టాల్ చేయాలి. మీరు వీటన్నింటినీ మాన్యువల్‌గా పర్యవేక్షించవచ్చు, నోడ్‌లు మారితే మానిఫెస్ట్‌లను తిరిగి వ్రాయడం. కానీ ఇది తీవ్రమైన విధానం కాదు; ఆటోమేషన్ చాలా మంచిది.

నోడ్‌ల గురించి సమాచారాన్ని పొందడానికి, పప్పెట్‌లో వాస్తవాలు అనే మెకానిజం ఉంది. వాస్తవాలు - ఇది నోడ్ గురించిన సమాచారం, గ్లోబల్ నేమ్‌స్పేస్‌లో సాధారణ వేరియబుల్స్ రూపంలో మానిఫెస్ట్‌లలో అందుబాటులో ఉంటుంది. ఉదాహరణకు, హోస్ట్ పేరు, ఆపరేటింగ్ సిస్టమ్ వెర్షన్, ప్రాసెసర్ ఆర్కిటెక్చర్, వినియోగదారుల జాబితా, నెట్‌వర్క్ ఇంటర్‌ఫేస్‌ల జాబితా మరియు వాటి చిరునామాలు మరియు చాలా ఎక్కువ. వాస్తవాలు మానిఫెస్ట్‌లు మరియు టెంప్లేట్‌లలో సాధారణ వేరియబుల్‌లుగా అందుబాటులో ఉంటాయి.

వాస్తవాలతో పని చేయడానికి ఉదాహరణ:

notify { "Running OS ${facts['os']['name']} version ${facts['os']['release']['full']}": }
# ресурс типа notify просто выводит сообщение в лог

అధికారికంగా చెప్పాలంటే, ఒక వాస్తవం పేరు (స్ట్రింగ్) మరియు విలువను కలిగి ఉంటుంది (వివిధ రకాలు అందుబాటులో ఉన్నాయి: స్ట్రింగ్‌లు, శ్రేణులు, నిఘంటువులు). తినండి అంతర్నిర్మిత వాస్తవాల సమితి. మీరు మీ స్వంతంగా కూడా వ్రాయవచ్చు. ఫాక్ట్ కలెక్టర్లు వివరించబడ్డాయి రూబీలో విధులు వంటివిలేదా ఎలా ఎక్జిక్యూటబుల్ ఫైల్స్. వాస్తవాలను కూడా రూపంలో అందించవచ్చు డేటాతో టెక్స్ట్ ఫైల్స్ నోడ్స్ మీద.

ఆపరేషన్ సమయంలో, పప్పెట్ ఏజెంట్ మొదట అందుబాటులో ఉన్న అన్ని వాస్తవ సేకరణలను pappetserver నుండి నోడ్‌కు కాపీ చేస్తుంది, ఆ తర్వాత అది వాటిని ప్రారంభించి, సేకరించిన వాస్తవాలను సర్వర్‌కు పంపుతుంది; దీని తరువాత, సర్వర్ కేటలాగ్‌ను కంపైల్ చేయడం ప్రారంభిస్తుంది.

ఎక్జిక్యూటబుల్ ఫైల్‌ల రూపంలో వాస్తవాలు

ఇటువంటి వాస్తవాలు డైరెక్టరీలోని మాడ్యూల్స్‌లో ఉంచబడతాయి facts.d. వాస్తవానికి, ఫైల్‌లు తప్పనిసరిగా ఎక్జిక్యూటబుల్‌గా ఉండాలి. అమలు చేసినప్పుడు, వారు తప్పనిసరిగా YAML లేదా కీ=విలువ ఆకృతిలో ప్రామాణిక అవుట్‌పుట్‌కు సమాచారాన్ని అవుట్‌పుట్ చేయాలి.

మీ మాడ్యూల్ అమలు చేయబడిన పాపెట్ సర్వర్ ద్వారా నియంత్రించబడే అన్ని నోడ్‌లకు వాస్తవాలు వర్తిస్తాయని మర్చిపోవద్దు. అందువల్ల, స్క్రిప్ట్‌లో, మీ వాస్తవం పని చేయడానికి అవసరమైన అన్ని ప్రోగ్రామ్‌లు మరియు ఫైల్‌లను సిస్టమ్ కలిగి ఉందో లేదో తనిఖీ చేయండి.

#!/bin/sh
echo "testfact=success"

#!/bin/sh
echo '{"testyamlfact":"success"}'

రూబీ వాస్తవాలు

ఇటువంటి వాస్తవాలు డైరెక్టరీలోని మాడ్యూల్స్‌లో ఉంచబడతాయి lib/facter.

# всё начинается с вызова функции Facter.add с именем факта и блоком кода
Facter.add('ladvd') do
# в блоках confine описываются условия применимости факта — код внутри блока должен вернуть true, иначе значение факта не вычисляется и не возвращается
  confine do
    Facter::Core::Execution.which('ladvdc') # проверим, что в PATH есть такой исполняемый файл
  end
  confine do
    File.socket?('/var/run/ladvd.sock') # проверим, что есть такой UNIX-domain socket
  end
# в блоке setcode происходит собственно вычисление значения факта
  setcode do
    hash = {}
    if (out = Facter::Core::Execution.execute('ladvdc -b'))
      out.split.each do |l|
        line = l.split('=')
        next if line.length != 2
        name, value = line
        hash[name.strip.downcase.tr(' ', '_')] = value.strip.chomp(''').reverse.chomp(''').reverse
      end
    end
    hash  # значение последнего выражения в блоке setcode является значением факта
  end
end

టెక్స్ట్ వాస్తవాలు

ఇటువంటి వాస్తవాలు డైరెక్టరీలో నోడ్స్‌లో ఉంచబడతాయి /etc/facter/facts.d పాత పప్పెట్‌లో లేదా /etc/puppetlabs/facts.d కొత్త పప్పెట్‌లో.

examplefact=examplevalue

---
examplefact2: examplevalue2
anotherfact: anothervalue

వాస్తవాలను పొందడం

వాస్తవాలను చేరుకోవడానికి రెండు మార్గాలు ఉన్నాయి:

నిఘంటువు ద్వారా $facts: $facts['fqdn'];
వాస్తవ పేరును వేరియబుల్ పేరుగా ఉపయోగించడం: $fqdn.

నిఘంటువును ఉపయోగించడం ఉత్తమం $facts, లేదా ఇంకా మెరుగైనది, గ్లోబల్ నేమ్‌స్పేస్‌ని సూచించండి ($::facts).

డాక్యుమెంటేషన్ యొక్క సంబంధిత విభాగం ఇక్కడ ఉంది.

అంతర్నిర్మిత వేరియబుల్స్

వాస్తవాలతో పాటు, కూడా ఉంది కొన్ని వేరియబుల్స్, గ్లోబల్ నేమ్‌స్పేస్‌లో అందుబాటులో ఉంది.

విశ్వసనీయ వాస్తవాలు — క్లయింట్ యొక్క సర్టిఫికేట్ నుండి తీసుకోబడిన వేరియబుల్స్ (సర్టిఫికేట్ సాధారణంగా పాప్పెట్ సర్వర్‌లో జారీ చేయబడినందున, ఏజెంట్ దాని సర్టిఫికేట్ తీసుకోలేరు మరియు మార్చలేరు, కాబట్టి వేరియబుల్స్ “విశ్వసనీయమైనవి”): సర్టిఫికేట్ పేరు, పేరు హోస్ట్ మరియు డొమైన్, సర్టిఫికేట్ నుండి పొడిగింపులు.
సర్వర్ వాస్తవాలు —సర్వర్-వెర్షన్, పేరు, సర్వర్ IP చిరునామా, పర్యావరణం గురించిన సమాచారానికి సంబంధించిన వేరియబుల్స్.
ఏజెంట్ వాస్తవాలు — వేరియబుల్స్ నేరుగా పప్పెట్-ఏజెంట్ ద్వారా జోడించబడ్డాయి మరియు ఫ్యాక్టర్ ద్వారా కాదు — సర్టిఫికేట్ పేరు, ఏజెంట్ వెర్షన్, పప్పెట్ వెర్షన్.
మాస్టర్ వేరియబుల్స్ - Pappetmaster వేరియబుల్స్ (sic!). ఇది దాదాపు లో ఉన్నట్లే సర్వర్ వాస్తవాలు, ప్లస్ కాన్ఫిగరేషన్ పరామితి విలువలు అందుబాటులో ఉన్నాయి.
కంపైలర్ వేరియబుల్స్ — ప్రతి స్కోప్‌లో విభిన్నమైన కంపైలర్ వేరియబుల్స్: ప్రస్తుత మాడ్యూల్ పేరు మరియు ప్రస్తుత వస్తువు యాక్సెస్ చేయబడిన మాడ్యూల్ పేరు. ఉదాహరణకు, మీ ప్రైవేట్ తరగతులు ఇతర మాడ్యూళ్ల నుండి నేరుగా ఉపయోగించబడటం లేదని తనిఖీ చేయడానికి వాటిని ఉపయోగించవచ్చు.

అదనంగా 1: వీటన్నింటినీ ఎలా అమలు చేయాలి మరియు డీబగ్ చేయాలి?

వ్యాసంలో పప్పెట్ కోడ్‌కి సంబంధించిన అనేక ఉదాహరణలు ఉన్నాయి, కానీ ఈ కోడ్‌ని ఎలా అమలు చేయాలో మాకు చెప్పలేదు. సరే, నన్ను నేను సరిదిద్దుకుంటున్నాను.

పప్పెట్‌ని అమలు చేయడానికి ఏజెంట్ సరిపోతుంది, కానీ చాలా సందర్భాలలో మీకు సర్వర్ కూడా అవసరం.

ఏజెంట్

కనీసం వెర్షన్ XNUMX నుండి, పప్పెట్-ఏజెంట్ ప్యాకేజీలు అధికారిక పప్పెట్‌ల్యాబ్స్ రిపోజిటరీ అన్ని డిపెండెన్సీలను కలిగి ఉంటుంది (రూబీ మరియు సంబంధిత రత్నాలు), కాబట్టి ఇన్‌స్టాలేషన్ ఇబ్బందులు లేవు (నేను డెబియన్ ఆధారిత పంపిణీల గురించి మాట్లాడుతున్నాను - మేము RPM-ఆధారిత పంపిణీలను ఉపయోగించము).

సరళమైన సందర్భంలో, పప్పెట్ కాన్ఫిగరేషన్‌ను ఉపయోగించడానికి, ఏజెంట్‌ను సర్వర్‌లెస్ మోడ్‌లో ప్రారంభించడం సరిపోతుంది: పప్పెట్ కోడ్ నోడ్‌కి కాపీ చేయబడితే, ప్రారంభించండి puppet apply <путь к манифесту>:

atikhonov@atikhonov ~/puppet-test $ cat helloworld.pp 
node default {
    notify { 'Hello world!': }
}
atikhonov@atikhonov ~/puppet-test $ puppet apply helloworld.pp 
Notice: Compiled catalog for atikhonov.localdomain in environment production in 0.01 seconds
Notice: Hello world!
Notice: /Stage[main]/Main/Node[default]/Notify[Hello world!]/message: defined 'message' as 'Hello world!'
Notice: Applied catalog in 0.01 seconds

డెమోన్ మోడ్‌లో సర్వర్‌ను సెటప్ చేయడం మరియు నోడ్‌లలో ఏజెంట్లను అమలు చేయడం మంచిది - అప్పుడు ప్రతి అరగంటకు ఒకసారి వారు సర్వర్ నుండి డౌన్‌లోడ్ చేసిన కాన్ఫిగరేషన్‌ను వర్తింపజేస్తారు.

మీరు పని యొక్క పుష్ మోడల్‌ను అనుకరించవచ్చు - మీకు ఆసక్తి ఉన్న నోడ్‌కి వెళ్లి ప్రారంభించండి sudo puppet agent -t. కీ -t (--test) వాస్తవానికి వ్యక్తిగతంగా ప్రారంభించబడే అనేక ఎంపికలను కలిగి ఉంటుంది. ఈ ఎంపికలు క్రింది వాటిని కలిగి ఉంటాయి:

డెమోన్ మోడ్‌లో అమలు చేయవద్దు (డిఫాల్ట్‌గా ఏజెంట్ డెమోన్ మోడ్‌లో ప్రారంభమవుతుంది);
కేటలాగ్‌ను వర్తింపజేసిన తర్వాత మూసివేయబడుతుంది (డిఫాల్ట్‌గా, ఏజెంట్ పని చేస్తూనే ఉంటుంది మరియు ప్రతి అరగంటకు ఒకసారి కాన్ఫిగరేషన్‌ను వర్తింపజేస్తుంది);
వివరణాత్మక పని లాగ్ వ్రాయండి;
ఫైళ్లలో మార్పులను చూపుతుంది.

ఏజెంట్ మార్పులు లేకుండా ఆపరేటింగ్ మోడ్‌ను కలిగి ఉంది - మీరు సరైన కాన్ఫిగరేషన్‌ను వ్రాసారని మీకు ఖచ్చితంగా తెలియనప్పుడు మరియు ఆపరేషన్ సమయంలో ఏజెంట్ ఖచ్చితంగా ఏమి మారుస్తుందో తనిఖీ చేయాలనుకున్నప్పుడు మీరు దాన్ని ఉపయోగించవచ్చు. ఈ మోడ్ పారామీటర్ ద్వారా ప్రారంభించబడింది --noop కమాండ్ లైన్‌లో: sudo puppet agent -t --noop.

అదనంగా, మీరు పని యొక్క డీబగ్గింగ్ లాగ్‌ను ప్రారంభించవచ్చు - దానిలో, తోలుబొమ్మ అది చేసే అన్ని చర్యల గురించి వ్రాస్తుంది: ఇది ప్రస్తుతం ప్రాసెస్ చేస్తున్న వనరు గురించి, ఈ వనరు యొక్క పారామితుల గురించి, ఏ ప్రోగ్రామ్‌లను ప్రారంభించాలో గురించి. వాస్తవానికి ఇది ఒక పరామితి --debug.

సర్వర్

నేను ఈ వ్యాసంలో పాపెట్ సర్వర్ యొక్క పూర్తి సెటప్ మరియు దానికి కోడ్‌ని అమలు చేయడాన్ని పరిగణించను; తక్కువ సంఖ్యలో పని చేయడానికి అదనపు కాన్ఫిగరేషన్ అవసరం లేని సర్వర్ యొక్క పూర్తి ఫంక్షనల్ వెర్షన్ బాక్స్ వెలుపల ఉందని మాత్రమే నేను చెబుతాను. నోడ్స్ (చెప్పండి, వంద వరకు). పెద్ద సంఖ్యలో నోడ్‌లకు ట్యూనింగ్ అవసరం - డిఫాల్ట్‌గా, పప్పెట్‌సర్వర్ నలుగురు కంటే ఎక్కువ మంది కార్మికులను లాంచ్ చేయదు, ఎక్కువ పనితీరు కోసం మీరు వారి సంఖ్యను పెంచాలి మరియు మెమరీ పరిమితులను పెంచడం మర్చిపోవద్దు, లేకపోతే సర్వర్ ఎక్కువ సమయం చెత్తను సేకరిస్తుంది.

కోడ్ విస్తరణ - మీకు త్వరగా మరియు సులభంగా అవసరమైతే, చూడండి (r10k వద్ద)[https://github.com/puppetlabs/r10k], చిన్న సంస్థాపనలకు ఇది చాలా సరిపోతుంది.

అనుబంధం 2: కోడింగ్ మార్గదర్శకాలు

అన్ని తర్కాలను తరగతులు మరియు నిర్వచనాలలో ఉంచండి.
తరగతులు మరియు నిర్వచనాలను మాడ్యూల్స్‌లో ఉంచండి, నోడ్‌లను వివరించే మానిఫెస్ట్‌లలో కాదు.
వాస్తవాలను ఉపయోగించండి.
హోస్ట్ పేర్ల ఆధారంగా ifs చేయవద్దు.
తరగతులు మరియు నిర్వచనాల కోసం పారామితులను జోడించడానికి సంకోచించకండి - ఇది క్లాస్/డిఫైన్ బాడీలో దాగి ఉన్న అవ్యక్త తర్కం కంటే మెరుగైనది.

నేను దీన్ని ఎందుకు సిఫార్సు చేస్తున్నాను తదుపరి వ్యాసంలో వివరిస్తాను.

తీర్మానం

పరిచయంతో ముగిద్దాం. తదుపరి కథనంలో నేను మీకు Hiera, ENC మరియు PuppetDB గురించి చెబుతాను.

నమోదు చేసుకున్న వినియోగదారులు మాత్రమే సర్వేలో పాల్గొనగలరు. సైన్ ఇన్ చేయండిదయచేసి.

వాస్తవానికి, చాలా ఎక్కువ విషయాలు ఉన్నాయి - నేను ఈ క్రింది అంశాలపై కథనాలను వ్రాయగలను, మీరు చదవడానికి ఆసక్తి ఉన్న వాటిపై ఓటు వేయండి:

59,1%అధునాతన తోలుబొమ్మ నిర్మాణాలు - కొన్ని తదుపరి-స్థాయి షిట్: లూప్‌లు, మ్యాపింగ్ మరియు ఇతర లాంబ్డా వ్యక్తీకరణలు, రిసోర్స్ కలెక్టర్లు, ఎగుమతి చేయబడిన వనరులు మరియు పప్పెట్, ట్యాగ్‌లు, ప్రొవైడర్లు, అబ్‌స్ట్రాక్ట్ డేటా రకాలు ద్వారా ఇంటర్-హోస్ట్ కమ్యూనికేషన్.13
31,8%"నేను నా తల్లి అడ్మిన్" లేదా మేము Avitoలో వివిధ వెర్షన్‌ల యొక్క అనేక పాపెట్ సర్వర్‌లతో ఎలా స్నేహం చేసాము మరియు సూత్రప్రాయంగా, పాపెట్ సర్వర్‌ని నిర్వహించడం గురించిన భాగం.7
81,8%మేము పప్పెట్ కోడ్‌ను ఎలా వ్రాస్తాము: ఇన్‌స్ట్రుమెంటేషన్, డాక్యుమెంటేషన్, టెస్టింగ్, CI/CD.18

22 మంది వినియోగదారులు ఓటు వేశారు. 9 మంది వినియోగదారులు దూరంగా ఉన్నారు.

మూలం: www.habr.com

పప్పెట్ పరిచయం

ప్రాథమిక సమాచారం

మేనిఫెస్టోలకు పరిచయం

సింటాక్స్ మరియు కోడ్‌స్టైల్

pappetserverలో ఫైల్‌ల స్థానం

కొన్ని పోరాట ఉదాహరణలు

నోడ్ మరియు దానిపై వనరు యొక్క వివరణ

నోడ్‌లోని వనరుల మధ్య సంబంధాలు

వనరుల రకాలు

ఫైలు

ప్యాకేజీ

సేవ

కార్యనిర్వాహకుడు

క్రాన్

సాధారణంగా వనరుల గురించి

వనరుల ప్రత్యేకత కోసం అవసరాలు

మెటాపారామీటర్లు

వనరులకు లింక్‌లు

డిపెండెన్సీలు మరియు నోటిఫికేషన్‌లు

పేర్కొనబడని పారామితులను నిర్వహించడం

తరగతులు, వేరియబుల్స్ మరియు నిర్వచనాలకు పరిచయం

తరగతుల

వేరియబుల్స్

తరగతులు: తరగతి పేరు vs తరగతి{'తరగతి పేరు':}

నిర్వచిస్తుంది

తరగతులు మరియు నిర్వచనాల కోసం డిపెండెన్సీలు మరియు నోటిఫికేషన్‌లు

షరతులతో కూడిన ప్రకటనలు మరియు ఎంపికదారులు

if

తప్ప

కేసు

సెలెక్టర్లు

గుణకాలు

మాడ్యూల్‌లో ఫైల్ నిర్మాణం

మాడ్యూల్‌లోని వనరుల పేర్లు మరియు ఫైల్‌ల పేర్లు

పద్ధతులు

ERB గురించి క్లుప్తంగా

టెంప్లేట్ ఉపయోగించి ఉదాహరణ

వాస్తవాలు మరియు అంతర్నిర్మిత వేరియబుల్స్

ఎక్జిక్యూటబుల్ ఫైల్‌ల రూపంలో వాస్తవాలు

రూబీ వాస్తవాలు

టెక్స్ట్ వాస్తవాలు

వాస్తవాలను పొందడం

అంతర్నిర్మిత వేరియబుల్స్

అదనంగా 1: వీటన్నింటినీ ఎలా అమలు చేయాలి మరియు డీబగ్ చేయాలి?

ఏజెంట్

సర్వర్

అనుబంధం 2: కోడింగ్ మార్గదర్శకాలు

తీర్మానం