អាយ៉ងគឺជាប្រព័ន្ធគ្រប់គ្រងការកំណត់រចនាសម្ព័ន្ធ។ វា​ត្រូវ​បាន​ប្រើ​ដើម្បី​នាំ​យក​ម៉ាស៊ីន​ទៅ​រដ្ឋ​ដែល​ចង់​បាន​និង​រក្សា​រដ្ឋ​នេះ​។

ខ្ញុំបានធ្វើការជាមួយ Puppet អស់រយៈពេលជាងប្រាំឆ្នាំមកហើយ។ អត្ថបទនេះពិតជាការបកប្រែ និងរៀបចំចងក្រងឡើងវិញនូវចំណុចសំខាន់ៗពីឯកសារផ្លូវការ ដែលនឹងអនុញ្ញាតឱ្យអ្នកចាប់ផ្តើមស្វែងយល់យ៉ាងឆាប់រហ័សអំពីខ្លឹមសារនៃអាយ៉ង។

ព័ត៌មានមូលដ្ឋាន

ប្រព័ន្ធប្រតិបត្តិការរបស់ Puppet គឺជាម៉ាស៊ីនភ្ញៀវ-ម៉ាស៊ីនមេ ទោះបីជាវាក៏គាំទ្រប្រតិបត្តិការគ្មានម៉ាស៊ីនមេ ជាមួយនឹងមុខងារមានកំណត់ក៏ដោយ។

ម៉ូដែលទាញនៃប្រតិបត្តិការត្រូវបានប្រើ៖ តាមលំនាំដើម រៀងរាល់កន្លះម៉ោងម្តង អតិថិជនទាក់ទងម៉ាស៊ីនមេសម្រាប់ការកំណត់រចនាសម្ព័ន្ធ ហើយអនុវត្តវា។ ប្រសិនបើអ្នកបានធ្វើការជាមួយ Ansible បន្ទាប់មកពួកគេប្រើគំរូជំរុញផ្សេង៖ អ្នកគ្រប់គ្រងចាប់ផ្តើមដំណើរការអនុវត្តការកំណត់ អតិថិជនខ្លួនឯងនឹងមិនអនុវត្តអ្វីទាំងអស់។

ក្នុងអំឡុងពេលទំនាក់ទំនងបណ្តាញ ការអ៊ិនគ្រីប TLS ពីរផ្លូវត្រូវបានប្រើ៖ ម៉ាស៊ីនមេ និងម៉ាស៊ីនភ្ញៀវមានសោឯកជនផ្ទាល់ខ្លួន និងវិញ្ញាបនបត្រដែលត្រូវគ្នា។ ជាធម្មតាម៉ាស៊ីនមេចេញវិញ្ញាបនបត្រសម្រាប់អតិថិជន ប៉ុន្តែជាគោលការណ៍វាអាចប្រើ CA ខាងក្រៅបាន។

ការណែនាំអំពីការបង្ហាញ

នៅក្នុងវចនានុក្រមអាយ៉ង ទៅម៉ាស៊ីនមេអាយ៉ង ភ្ជាប់ ថ្នាំង (ថ្នាំង) ។ ការកំណត់រចនាសម្ព័ន្ធសម្រាប់ថ្នាំងត្រូវបានសរសេរ នៅក្នុង manifestos នៅក្នុងភាសាសរសេរកម្មវិធីពិសេស - អាយ៉ង DSL ។

អាយ៉ង DSL គឺជាភាសាប្រកាស។ វាពិពណ៌នាអំពីស្ថានភាពដែលចង់បានរបស់ថ្នាំងក្នុងទម្រង់នៃការប្រកាសនៃធនធានបុគ្គល ឧទាហរណ៍៖

• ឯកសារមាន ហើយវាមានខ្លឹមសារជាក់លាក់។
• កញ្ចប់ត្រូវបានដំឡើង។
• សេវាកម្មបានចាប់ផ្តើមហើយ។

ធនធានអាចទាក់ទងគ្នាទៅវិញទៅមក៖

• មានភាពអាស្រ័យពួកគេប៉ះពាល់ដល់លំដាប់ដែលធនធានត្រូវបានប្រើប្រាស់។
  ឧទាហរណ៍ "ដំឡើងកញ្ចប់ដំបូង បន្ទាប់មកកែសម្រួលឯកសារកំណត់រចនាសម្ព័ន្ធ បន្ទាប់មកចាប់ផ្តើមសេវាកម្ម។"
• មានការជូនដំណឹង - ប្រសិនបើធនធានបានផ្លាស់ប្តូរ វាផ្ញើការជូនដំណឹងទៅកាន់ធនធានដែលបានជាវវា។
  ឧទាហរណ៍ ប្រសិនបើឯកសារកំណត់រចនាសម្ព័ន្ធផ្លាស់ប្តូរ អ្នកអាចចាប់ផ្តើមសេវាកម្មឡើងវិញដោយស្វ័យប្រវត្តិ។

លើសពីនេះទៀត Puppet DSL មានមុខងារ និងអថេរ ក៏ដូចជាសេចក្តីថ្លែងការណ៍តាមលក្ខខណ្ឌ និងឧបករណ៍ជ្រើសរើស។ យន្តការគំរូផ្សេងៗក៏ត្រូវបានគាំទ្រផងដែរ - EPP និង ERB ។

អាយ៉ង​ត្រូវ​បាន​សរសេរ​ជា Ruby ដូច្នេះ​ការ​សាងសង់ និង​ពាក្យ​ជា​ច្រើន​ត្រូវ​បាន​យក​ចេញ​ពី​ទីនោះ។ Ruby អនុញ្ញាតឱ្យអ្នកពង្រីកអាយ៉ង - បន្ថែមតក្កវិជ្ជាស្មុគស្មាញ ប្រភេទធនធានថ្មី មុខងារ។

ខណៈពេលដែល Puppet កំពុងដំណើរការ ការបង្ហាញសម្រាប់ថ្នាំងជាក់លាក់នីមួយៗនៅលើម៉ាស៊ីនមេត្រូវបានចងក្រងទៅក្នុងថតមួយ។ ថត គឺជាបញ្ជីនៃធនធាន និងទំនាក់ទំនងរបស់ពួកគេបន្ទាប់ពីគណនាតម្លៃនៃមុខងារ អថេរ និងការពង្រីកនៃសេចក្តីថ្លែងការណ៍តាមលក្ខខណ្ឌ។

វាក្យសម្ព័ន្ធ និងរចនាប័ទ្មកូដ

នេះគឺជាផ្នែកនៃឯកសារផ្លូវការដែលនឹងជួយអ្នកឱ្យយល់ពីវាក្យសម្ព័ន្ធ ប្រសិនបើឧទាហរណ៍ដែលបានផ្តល់មិនគ្រប់គ្រាន់៖

• វាក្យសម្ព័ន្ធនៃរចនាសម្ព័ន្ធភាសាផ្សេងៗ។
• វាក្យសម្ព័ន្ធធនធាន។
• វាក្យសម្ព័ន្ធសម្រាប់ការពិពណ៌នាថ្នាំង។

នេះគឺជាឧទាហរណ៍នៃអ្វីដែល manifest មើលទៅដូច៖

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

ការចូលបន្ទាត់ និងការបំបែកបន្ទាត់មិនមែនជាផ្នែកដែលត្រូវការនៃ manifest នោះទេ ប៉ុន្តែវាត្រូវបានណែនាំ រចនាប័ទ្ម. សង្ខេប៖

• ការ​ចូល​បន្ទាត់​ចន្លោះ​ពីរ ផ្ទាំង​មិន​ត្រូវ​បាន​ប្រើ​ទេ។
• ដង្កៀបកោងត្រូវបានបំបែកដោយចន្លោះមួយ;
• សញ្ញាក្បៀសបន្ទាប់ពីប៉ារ៉ាម៉ែត្រនីមួយៗ រួមទាំងលេខចុងក្រោយ។ ប៉ារ៉ាម៉ែត្រនីមួយៗស្ថិតនៅលើបន្ទាត់ដាច់ដោយឡែក។ ករណីលើកលែងមួយត្រូវបានបង្កើតឡើងសម្រាប់ករណីដោយគ្មានប៉ារ៉ាម៉ែត្រ និងប៉ារ៉ាម៉ែត្រមួយ៖ អ្នកអាចសរសេរលើបន្ទាត់មួយ និងដោយគ្មានសញ្ញាក្បៀស (ឧ។ resource { 'title': } и resource { 'title': param => value }).
• ព្រួញនៅលើប៉ារ៉ាម៉ែត្រគួរតែនៅកម្រិតដូចគ្នា។
• ព្រួញទំនាក់ទំនងធនធានត្រូវបានសរសេរនៅពីមុខពួកគេ។

ទីតាំងនៃឯកសារនៅលើ pappetserver

សម្រាប់ការពន្យល់បន្ថែម ខ្ញុំនឹងណែនាំពីគោលគំនិតនៃ "ថតឯកសារ"។ ថតឫសគឺជាថតដែលមានការកំណត់រចនាសម្ព័ន្ធអាយ៉ងសម្រាប់ថ្នាំងជាក់លាក់មួយ។

ថត root ប្រែប្រួលអាស្រ័យលើកំណែរបស់ Puppet និងបរិស្ថានដែលបានប្រើ។ បរិស្ថានគឺជាសំណុំឯករាជ្យនៃការកំណត់រចនាសម្ព័ន្ធដែលត្រូវបានរក្សាទុកក្នុងថតដាច់ដោយឡែក។ ជាធម្មតាប្រើក្នុងការរួមបញ្ចូលគ្នាជាមួយ git នៅក្នុងករណីដែលបរិស្ថានត្រូវបានបង្កើតឡើងពីសាខា git ។ ដូច្នោះហើយថ្នាំងនីមួយៗមានទីតាំងនៅក្នុងបរិយាកាសមួយឬផ្សេងទៀត។ វាអាចត្រូវបានកំណត់រចនាសម្ព័ន្ធនៅលើថ្នាំងខ្លួនវា ឬនៅក្នុង ENC ដែលខ្ញុំនឹងនិយាយអំពីនៅក្នុងអត្ថបទបន្ទាប់។

• នៅក្នុងកំណែទីបី ("អាយ៉ងចាស់") ថតមូលដ្ឋានគឺ /etc/puppet. ការប្រើប្រាស់បរិស្ថានគឺស្រេចចិត្ត - ឧទាហរណ៍ យើងមិនប្រើពួកវាជាមួយអាយ៉ងចាស់ទេ។ ប្រសិនបើបរិស្ថានត្រូវបានប្រើប្រាស់ ជាធម្មតាពួកវាត្រូវបានរក្សាទុកនៅក្នុង /etc/puppet/environmentsថត root នឹងជាថតបរិស្ថាន។ ប្រសិនបើបរិស្ថានមិនត្រូវបានប្រើ ថតឫសនឹងជាថតមូលដ្ឋាន។
• ចាប់ផ្តើមពីកំណែទីបួន ("អាយ៉ងថ្មី") ការប្រើប្រាស់បរិស្ថានបានក្លាយជាកាតព្វកិច្ច ហើយបញ្ជីមូលដ្ឋានត្រូវបានផ្លាស់ប្តូរទៅ /etc/puppetlabs/code. ដូច្នោះហើយបរិស្ថានត្រូវបានរក្សាទុកនៅក្នុង /etc/puppetlabs/code/environments, ថត root គឺជាថតបរិស្ថាន។

ត្រូវតែមានថតរងនៅក្នុងថត root manifestsដែលមានការបង្ហាញមួយ ឬច្រើនដែលពិពណ៌នាអំពីថ្នាំង។ លើសពីនេះទៀតគួរតែមានថតរង modulesដែលមានម៉ូឌុល។ ខ្ញុំនឹងប្រាប់អ្នកពីម៉ូឌុលណាមួយនៅពេលក្រោយ។ លើសពីនេះ អាយ៉ងចាស់ក៏អាចមានថតរងផងដែរ។ filesដែលមានឯកសារជាច្រើនដែលយើងចម្លងទៅថ្នាំង។ នៅក្នុងអាយ៉ងថ្មី ឯកសារទាំងអស់ត្រូវបានដាក់ក្នុងម៉ូឌុល។

ឯកសារ Manifest មានផ្នែកបន្ថែម .pp.

ឧទាហរណ៍នៃការប្រយុទ្ធពីរបី

ការពិពណ៌នាអំពីថ្នាំង និងធនធាននៅលើវា។

នៅលើថ្នាំង server1.testdomain ឯកសារត្រូវតែបង្កើត /etc/issue ជាមួយនឹងមាតិកា Debian GNU/Linux n l. ឯកសារត្រូវតែជាកម្មសិទ្ធិរបស់អ្នកប្រើ និងក្រុម rootសិទ្ធិចូលប្រើត្រូវតែមាន 644.

យើងសរសេរ manifesto៖

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.
• ប្រសិនបើការកំណត់រចនាសម្ព័ន្ធត្រូវបានធ្វើបច្ចុប្បន្នភាព សេវាកម្មត្រូវតែចាប់ផ្តើមឡើងវិញ។

យើងសរសេរ manifesto៖

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 មូលដ្ឋាននៅលើថ្នាំងនឹងត្រូវបានប្រើ)
• គោលដៅ - កន្លែងដែលនិមិត្តសញ្ញាគួរចង្អុល (មិនអាចប្រើរួមគ្នាជាមួយ មាតិកា ឬ ប្រភព)
• ម្ចាស់ - អ្នកប្រើប្រាស់ដែលគួរជាម្ចាស់ឯកសារ
• ក្រុម - ក្រុមដែលឯកសារគួរតែជាកម្មសិទ្ធិ
• របៀប - ការអនុញ្ញាតឯកសារ (ជាខ្សែអក្សរ)
• កើតឡើងវិញ។ - បើកដំណើរការថតចម្លងឡើងវិញ
• បន្សុទ្ធ - បើកការលុបឯកសារដែលមិនត្រូវបានពិពណ៌នានៅក្នុង Puppet
• កម្លាំង - បើកការលុបថតដែលមិនត្រូវបានពិពណ៌នានៅក្នុង Puppet

នីមួយៗ

ដំឡើង និងលុបកញ្ចប់។ អាចគ្រប់គ្រងការជូនដំណឹង - ដំឡើងកញ្ចប់ឡើងវិញប្រសិនបើប៉ារ៉ាម៉ែត្រត្រូវបានបញ្ជាក់ 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).
• hasstatus — ចង្អុលបង្ហាញថាតើសេវាកម្ម initscript គាំទ្រពាក្យបញ្ជា status។ បើ falseបន្ទាប់មកតម្លៃប៉ារ៉ាម៉ែត្រត្រូវបានប្រើ ស្ថានភាព. លំនាំដើម true.

ប្រតិបត្តិ

ដំណើរការពាក្យបញ្ជាខាងក្រៅ។ ប្រសិនបើអ្នកមិនបញ្ជាក់ប៉ារ៉ាម៉ែត្រ បង្កើត, តែប៉ុណ្ណោះ, លុះត្រាតែ ឬ ស្រស់ស្រាយពាក្យបញ្ជានឹងត្រូវបានដំណើរការរាល់ពេលដែល Puppet ត្រូវបានដំណើរការ។ អាចដំណើរការការជូនដំណឹង - ដំណើរការពាក្យបញ្ជា។

ប៉ារ៉ាម៉ែត្រ៖

• ឈ្មោះធនធាន - ពាក្យបញ្ជាដែលត្រូវប្រតិបត្តិ (ជាជម្រើស)
• ពាក្យបញ្ជា - ពាក្យបញ្ជាដែលត្រូវប្រតិបត្តិ (ប្រសិនបើវាមិនត្រូវបានបញ្ជាក់នៅក្នុងឈ្មោះ)
• ផ្លូវ - ផ្លូវដែលត្រូវរកមើលឯកសារដែលអាចប្រតិបត្តិបាន។
• តែប៉ុណ្ណោះ — ប្រសិនបើពាក្យបញ្ជាដែលបានបញ្ជាក់នៅក្នុងប៉ារ៉ាម៉ែត្រនេះបានបញ្ចប់ជាមួយនឹងលេខសូន្យ នោះពាក្យបញ្ជាចម្បងនឹងត្រូវបានប្រតិបត្តិ
• លុះត្រាតែ - ប្រសិនបើពាក្យបញ្ជាដែលបានបញ្ជាក់នៅក្នុងប៉ារ៉ាម៉ែត្រនេះបានបញ្ចប់ជាមួយនឹងលេខកូដត្រឡប់ដែលមិនមែនជាសូន្យនោះពាក្យបញ្ជាចម្បងនឹងត្រូវបានប្រតិបត្តិ
• បង្កើត — ប្រសិនបើឯកសារដែលបានបញ្ជាក់ក្នុងប៉ារ៉ាម៉ែត្រនេះមិនមានទេ ពាក្យបញ្ជាចម្បងនឹងត្រូវបានប្រតិបត្តិ
• ស្រស់ស្រាយ - ប្រសិនបើ trueបន្ទាប់មកពាក្យបញ្ជានឹងត្រូវបានដំណើរការតែនៅពេលដែលប្រតិបត្តិករនេះទទួលបានការជូនដំណឹងពីធនធានផ្សេងទៀត។
• cwd - ថតដែលត្រូវដំណើរការពាក្យបញ្ជា
• អ្នក​ប្រើ - អ្នកប្រើប្រាស់ពីអ្នកណាដែលត្រូវដំណើរការពាក្យបញ្ជា
• កំពូលមួយ - របៀបដំណើរការពាក្យបញ្ជា៖
  • posix - ដំណើរការកុមារត្រូវបានបង្កើតឡើងយ៉ាងសាមញ្ញ ត្រូវប្រាកដថាបញ្ជាក់ ផ្លូវ
  • សែល - ពាក្យបញ្ជាត្រូវបានដាក់ឱ្យដំណើរការនៅក្នុងសែល /bin/sh, អាចមិនត្រូវបានបញ្ជាក់ ផ្លូវអ្នកអាចប្រើ globbing, បំពង់ និងលក្ខណៈពិសេសសែលផ្សេងទៀត។ ជាធម្មតាត្រូវបានរកឃើញដោយស្វ័យប្រវត្តិ ប្រសិនបើមានតួអក្សរពិសេសណាមួយ (|, ;, &&, || ល​ល)។

cron

គ្រប់គ្រង cronjobs ។

ប៉ារ៉ាម៉ែត្រ៖

• ឈ្មោះធនធាន - គ្រាន់តែជាប្រភេទនៃអត្តសញ្ញាណមួយចំនួន
• ធានាឱ្យបាននូវ - ស្ថានភាពការងារ៖
  • present - បង្កើតប្រសិនបើមិនមាន
  • absent - លុបប្រសិនបើមាន
• ពាក្យបញ្ជា - តើពាក្យបញ្ជាអ្វីដែលត្រូវដំណើរការ
• បរិស្ថាន — ក្នុងបរិស្ថានណាដែលត្រូវដំណើរការពាក្យបញ្ជា (បញ្ជីអថេរបរិស្ថាន និងតម្លៃរបស់វាតាមរយៈ =)
• អ្នក​ប្រើ - ពីអ្នកប្រើប្រាស់ណាដែលត្រូវដំណើរការពាក្យបញ្ជា
• នាទី, ម៉ោង, ថ្ងៃធ្វើការ, ខែ, ថ្ងៃខែ - ពេលណាត្រូវដំណើរការ cron ។ ប្រសិនបើគុណលក្ខណៈទាំងនេះណាមួយមិនត្រូវបានបញ្ជាក់ តម្លៃរបស់វានៅក្នុង crontab នឹងមាន *.

នៅក្នុងអាយ៉ង 6.0 cron ដូចជាប្រសិនបើ យកចេញពីប្រអប់ នៅក្នុង puppetserver ដូច្នេះមិនមានឯកសារនៅលើគេហទំព័រទូទៅទេ។ ប៉ុន្តែ​គាត់ គឺនៅក្នុងប្រអប់ នៅក្នុង puppet-agent ដូច្នេះមិនចាំបាច់ដំឡើងវាដាច់ដោយឡែកទេ។ អ្នកអាចមើលឯកសារសម្រាប់វា។ នៅក្នុងឯកសារសម្រាប់កំណែទីប្រាំនៃអាយ៉ង, ឬ នៅលើ GitHub.

អំពីធនធានជាទូទៅ

តម្រូវការសម្រាប់ភាពប្លែកនៃធនធាន

កំហុសទូទៅបំផុតដែលយើងជួបប្រទះគឺ សេចក្តីប្រកាសស្ទួន. កំហុសនេះកើតឡើងនៅពេលដែលធនធានពីរឬច្រើននៃប្រភេទដូចគ្នាដែលមានឈ្មោះដូចគ្នាលេចឡើងក្នុងថត។

ដូច្នេះខ្ញុំនឹងសរសេរម្តងទៀត៖ manifests សម្រាប់ថ្នាំងដូចគ្នាមិនគួរមានធនធាននៃប្រភេទដូចគ្នាដែលមានចំណងជើងដូចគ្នា!

ជួនកាលមានតំរូវការក្នុងការដំឡើងកញ្ចប់ដែលមានឈ្មោះដូចគ្នា ប៉ុន្តែជាមួយនឹងកម្មវិធីគ្រប់គ្រងកញ្ចប់ផ្សេងៗគ្នា។ ក្នុងករណីនេះអ្នកត្រូវប្រើប៉ារ៉ាម៉ែត្រ 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']

ភាពអាស្រ័យ និងការជូនដំណឹង

ឯកសារនៅទីនេះ។

ដូចដែលបានបញ្ជាក់ពីមុន ភាពអាស្រ័យសាមញ្ញរវាងធនធានគឺជាអន្តរកាល។ ដោយវិធីនេះ សូមប្រយ័ត្ននៅពេលបន្ថែមភាពអាស្រ័យ - អ្នកអាចបង្កើតភាពអាស្រ័យវដ្ត ដែលនឹងបណ្តាលឱ្យមានកំហុសក្នុងការចងក្រង។

មិនដូចភាពអាស្រ័យ ការជូនដំណឹងមិនមែនជាអន្តរកាលទេ។ ច្បាប់ខាងក្រោមអនុវត្តសម្រាប់ការជូនដំណឹង៖

• ប្រសិនបើធនធានទទួលបានការជូនដំណឹង វាត្រូវបានធ្វើបច្ចុប្បន្នភាព។ សកម្មភាពអាប់ដេតអាស្រ័យលើប្រភេទធនធាន − ប្រតិបត្តិ ដំណើរការពាក្យបញ្ជា, សេវាកម្ម ចាប់ផ្តើមសេវាកម្មឡើងវិញ, នីមួយៗ ដំឡើងកញ្ចប់ឡើងវិញ។ ប្រសិនបើធនធានមិនមានសកម្មភាពអាប់ដេតដែលបានកំណត់ នោះគ្មានអ្វីកើតឡើងទេ។
• ក្នុងអំឡុងពេលដំណើរការនៃអាយ៉ង ធនធានត្រូវបានធ្វើបច្ចុប្បន្នភាពមិនលើសពីម្តងទេ។ វាអាចទៅរួច ដោយសារការជូនដំណឹងរួមបញ្ចូលភាពអាស្រ័យ ហើយក្រាហ្វភាពអាស្រ័យមិនមានវដ្ត។
• ប្រសិនបើ Puppet ផ្លាស់ប្តូរស្ថានភាពនៃធនធាន ធនធាននឹងផ្ញើការជូនដំណឹងទៅកាន់ធនធានទាំងអស់ដែលបានជាវវា។
• ប្រសិនបើធនធានត្រូវបានធ្វើបច្ចុប្បន្នភាព វាផ្ញើការជូនដំណឹងទៅកាន់ធនធានទាំងអស់ដែលបានជាវវា។

ដោះស្រាយប៉ារ៉ាម៉ែត្រដែលមិនបានបញ្ជាក់

តាមក្បួន ប្រសិនបើប៉ារ៉ាម៉ែត្រធនធានមួយចំនួនមិនមានតម្លៃលំនាំដើម ហើយប៉ារ៉ាម៉ែត្រនេះមិនត្រូវបានបញ្ជាក់នៅក្នុង manifest នោះ Puppet នឹងមិនផ្លាស់ប្តូរលក្ខណៈសម្បត្តិនេះសម្រាប់ធនធានដែលត្រូវគ្នានៅលើថ្នាំងនោះទេ។ ឧទាហរណ៍ប្រសិនបើធនធាននៃប្រភេទ ឯកសារ ប៉ារ៉ាម៉ែត្រមិនបានបញ្ជាក់ ownerបន្ទាប់មក Puppet នឹងមិនផ្លាស់ប្តូរម្ចាស់ឯកសារដែលត្រូវគ្នានោះទេ។

ការណែនាំអំពីថ្នាក់ អថេរ និងនិយមន័យ

ឧបមាថាយើងមានថ្នាំងជាច្រើនដែលមានផ្នែកដូចគ្នានៃការកំណត់រចនាសម្ព័ន្ធ ប៉ុន្តែក៏មានភាពខុសគ្នាផងដែរ - បើមិនដូច្នេះទេយើងអាចពណ៌នាវាទាំងអស់ក្នុងមួយប្លុក។ node {}. ជាការពិតណាស់ អ្នកអាចចម្លងផ្នែកដូចគ្នាបេះបិទនៃការកំណត់រចនាសម្ព័ន្ធ ប៉ុន្តែជាទូទៅនេះគឺជាដំណោះស្រាយមិនល្អ - ការកំណត់រចនាសម្ព័ន្ធរីកចម្រើន ហើយប្រសិនបើអ្នកផ្លាស់ប្តូរផ្នែកទូទៅនៃការកំណត់ អ្នកនឹងត្រូវកែសម្រួលរឿងដូចគ្នានៅកន្លែងជាច្រើន។ ក្នុងពេលជាមួយគ្នានេះ វាងាយស្រួលក្នុងការធ្វើខុស ហើយជាទូទៅ គោលការណ៍ DRY (កុំធ្វើម្តងទៀតដោយខ្លួនឯង) ត្រូវបានបង្កើតឡើងសម្រាប់ហេតុផលមួយ។

ដើម្បីដោះស្រាយបញ្ហានេះមានការរចនាដូចជា класс.

ថ្នាក់

Класс គឺជាប្លុកដែលមានឈ្មោះនៃកូដ poppet ។ ថ្នាក់ត្រូវការដើម្បីប្រើកូដឡើងវិញ។

ដំបូងថ្នាក់ត្រូវពិពណ៌នា។ ការពិពណ៌នាខ្លួនវាមិនបន្ថែមធនធាននៅកន្លែងណាមួយទេ។ ថ្នាក់ត្រូវបានពិពណ៌នានៅក្នុង manifests:

# Описание класса начинается с ключевого слова 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}"

អាយ៉ងមាន ចន្លោះឈ្មោះ, និងអថេរ, យោងទៅតាម, មាន តំបន់នៃការមើលឃើញ៖ អថេរ​ដែល​មាន​ឈ្មោះ​ដូចគ្នា​អាច​ត្រូវ​បាន​កំណត់​ក្នុង​ចន្លោះ​ឈ្មោះ​ផ្សេង​គ្នា។ នៅពេល​ដោះស្រាយ​តម្លៃ​នៃ​អថេរ អថេរ​ត្រូវ​បាន​ស្វែងរក​ក្នុង​ទំហំ​ឈ្មោះ​បច្ចុប្បន្ន បន្ទាប់​មក​ក្នុង​ចន្លោះ​ឈ្មោះ​ដែល​បាន​បិទ​ភ្ជាប់ ហើយ​ដូច្នេះ​នៅលើ។

ឧទាហរណ៍នៃទំហំឈ្មោះ៖

• សកល - អថេរនៅខាងក្រៅថ្នាក់ឬការពិពណ៌នាថ្នាំងទៅទីនោះ;
• node namespace នៅក្នុងការពិពណ៌នាថ្នាំង;
• class namespace នៅក្នុងការពិពណ៌នាថ្នាក់។

ដើម្បីជៀសវាងភាពមិនច្បាស់លាស់នៅពេលចូលប្រើអថេរ អ្នកអាចបញ្ជាក់ namespace ក្នុងឈ្មោះអថេរ៖

# переменная без пространства имён
$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
}

ទោះជាយ៉ាងណាក៏ដោយឧទាហរណ៍ដែលបានផ្តល់ឱ្យគឺមិនល្អទេពីព្រោះមាន "ចំណេះដឹងសម្ងាត់" ដែលនៅកន្លែងណាមួយនៅក្នុងថ្នាក់អថេរដែលមានឈ្មោះបែបនេះនិងឈ្មោះបែបនេះត្រូវបានប្រើ។ វាកាន់តែត្រឹមត្រូវក្នុងការធ្វើឱ្យចំណេះដឹងនេះមានលក្ខណៈទូទៅ - ថ្នាក់អាចមានប៉ារ៉ាម៉ែត្រ។

ប៉ារ៉ាម៉ែត្រថ្នាក់ គឺ​ជា​អថេរ​ក្នុង​ទំហំ​ឈ្មោះ​ថ្នាក់ ពួក​វា​ត្រូវ​បាន​បញ្ជាក់​ក្នុង​បឋមកថា​ថ្នាក់ ហើយ​អាច​ត្រូវ​បាន​ប្រើ​ដូច​ជា​អថេរ​ធម្មតា​ក្នុង​តួ​ថ្នាក់។ តម្លៃប៉ារ៉ាម៉ែត្រត្រូវបានបញ្ជាក់នៅពេលប្រើថ្នាក់ក្នុង manifest ។

ប៉ារ៉ាម៉ែត្រអាចត្រូវបានកំណត់ទៅជាតម្លៃលំនាំដើម។ ប្រសិនបើប៉ារ៉ាម៉ែត្រមិនមានតម្លៃលំនាំដើម ហើយតម្លៃមិនត្រូវបានកំណត់នៅពេលប្រើ វានឹងបណ្តាលឱ្យមានកំហុសក្នុងការចងក្រង។

ចូរយើងកំណត់ប៉ារ៉ាម៉ែត្រថ្នាក់ពីឧទាហរណ៍ខាងលើ ហើយបន្ថែមប៉ារ៉ាម៉ែត្រពីរ៖ ទីមួយ ទាមទារ គឺជាផ្លូវទៅកាន់ការកំណត់ ហើយទីពីរ ស្រេចចិត្ត គឺជាឈ្មោះកញ្ចប់ជាមួយ nginx (ឧទាហរណ៍នៅក្នុង Debian មានកញ្ចប់ 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,
) {
  ...
}

ថ្នាក់៖ រួមបញ្ចូលឈ្មោះថ្នាក់ និងថ្នាក់{'ឈ្មោះថ្នាក់':}

ថ្នាក់នីមួយៗគឺជាធនធាននៃប្រភេទ ថ្នាក់. ដូចនឹងប្រភេទធនធានផ្សេងទៀតដែរ មិនអាចមានឧទាហរណ៍ពីរនៃថ្នាក់ដូចគ្នានៅលើថ្នាំងដូចគ្នា។

ប្រសិនបើអ្នកព្យាយាមបន្ថែមថ្នាក់មួយទៅថ្នាំងដូចគ្នាពីរដងដោយប្រើ class { 'classname':} (មិនមានភាពខុសប្លែកគ្នា ជាមួយនឹងប៉ារ៉ាម៉ែត្រផ្សេងគ្នា ឬដូចគ្នាបេះបិទ) វានឹងមានកំហុសក្នុងការចងក្រង។ ប៉ុន្តែប្រសិនបើអ្នកប្រើ class ក្នុងរចនាប័ទ្មធនធាន អ្នកអាចកំណត់ប៉ារ៉ាម៉ែត្ររបស់វាទាំងអស់យ៉ាងច្បាស់លាស់ភ្លាមៗនៅក្នុង manifest ។

ទោះយ៉ាងណាក៏ដោយប្រសិនបើអ្នកប្រើ includeបន្ទាប់មក ថ្នាក់អាចត្រូវបានបន្ថែមច្រើនដងតាមការចង់បាន។ ការពិតគឺថា include គឺជាមុខងារ ideempotent ដែលពិនិត្យមើលថាតើ class ត្រូវបានបន្ថែមទៅ directory ដែរឬទេ។ ប្រសិនបើថ្នាក់មិនមាននៅក្នុងថត វាបន្ថែមវា ហើយប្រសិនបើវាមានរួចហើយ វាមិនធ្វើអ្វីទាំងអស់។ ប៉ុន្តែក្នុងករណីប្រើ include អ្នកមិនអាចកំណត់ប៉ារ៉ាម៉ែត្រថ្នាក់កំឡុងពេលប្រកាសថ្នាក់បានទេ - ប៉ារ៉ាម៉ែត្រដែលត្រូវការទាំងអស់ត្រូវតែកំណត់នៅក្នុងប្រភពទិន្នន័យខាងក្រៅ - Hiera ឬ ENC ។ យើងនឹងនិយាយអំពីពួកគេនៅក្នុងអត្ថបទបន្ទាប់។

កំណត់

ដូចដែលបាននិយាយនៅក្នុងប្លុកមុន ថ្នាក់ដូចគ្នាមិនអាចមានវត្តមាននៅលើ node ច្រើនជាងម្តងទេ។ ទោះយ៉ាងណាក៏ដោយ ក្នុងករណីខ្លះ អ្នកត្រូវការដើម្បីអាចប្រើប្លុកដូចគ្នានៃកូដដែលមានប៉ារ៉ាម៉ែត្រផ្សេងគ្នានៅលើថ្នាំងដូចគ្នា។ ម៉្យាងទៀត ត្រូវការប្រភេទធនធានផ្ទាល់ខ្លួន។

ឧទាហរណ៍ ដើម្បីដំឡើងម៉ូឌុល PHP យើងធ្វើដូចខាងក្រោមនៅក្នុង Avito:

1. ដំឡើងកញ្ចប់ជាមួយម៉ូឌុលនេះ។
2. តោះបង្កើតឯកសារកំណត់រចនាសម្ព័ន្ធសម្រាប់ម៉ូឌុលនេះ។
3. យើងបង្កើត symlink ទៅ config សម្រាប់ php-fpm ។
4. យើងបង្កើត symlink ទៅ config សម្រាប់ php cli ។

ក្នុងករណីបែបនេះការរចនាដូចជា កំណត់ (កំណត់ប្រភេទដែលបានកំណត់ ប្រភេទធនធានដែលបានកំណត់)។ A Define គឺស្រដៀងទៅនឹង class ប៉ុន្តែមានភាពខុសប្លែកគ្នា៖ ទីមួយ 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ប៉ុន្តែខ្ញុំនឹងប្រាប់អ្នកអំពីវានៅវគ្គបន្ទាប់។

ភាពអាស្រ័យ និងការជូនដំណឹងសម្រាប់ថ្នាក់ និងនិយមន័យ

ថ្នាក់ និងនិយមន័យបន្ថែមច្បាប់ខាងក្រោមដើម្បីដោះស្រាយភាពអាស្រ័យ និងការជូនដំណឹង៖

• ភាពអាស្រ័យទៅលើ class/define បន្ថែមភាពអាស្រ័យទៅលើធនធានទាំងអស់នៃ class/define;
• ថ្នាក់/កំណត់ភាពអាស្រ័យ បន្ថែមភាពអាស្រ័យទៅគ្រប់ថ្នាក់/កំណត់ធនធាន។
• class/define notification ជូនដំណឹងអំពីធនធានទាំងអស់នៃ class/define;
• class/define subscription ជាវធនធានទាំងអស់នៃ class/define។

សេចក្តីថ្លែងការណ៍តាមលក្ខខណ្ឌ និងជម្រើស

ឯកសារនៅទីនេះ។

if

វាសាមញ្ញនៅទីនេះ៖

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

លុះត្រាតែ

លុះត្រាតែជា if បញ្ច្រាស៖ ប្លុកនៃកូដនឹងត្រូវបានប្រតិបត្តិប្រសិនបើកន្សោមមិនពិត។

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

ករណី

មិនមានអ្វីស្មុគស្មាញនៅទីនេះទេ។ អ្នកអាចប្រើតម្លៃធម្មតា (ខ្សែអក្សរ លេខ។ល។) កន្សោមធម្មតា និងប្រភេទទិន្នន័យជាតម្លៃ។

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

អ្នកជ្រើសរើស

ឧបករណ៍ជ្រើសរើសគឺជាភាសាដែលស្រដៀងនឹង caseប៉ុន្តែជំនួសឱ្យការប្រតិបត្តិប្លុកនៃកូដ វាត្រឡប់តម្លៃមួយ។

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

ម៉ូឌុល

នៅពេលដែលការកំណត់រចនាសម្ព័ន្ធតូច វាអាចត្រូវបានរក្សាទុកយ៉ាងងាយស្រួលនៅក្នុងការបង្ហាញមួយ។ ប៉ុន្តែការកំណត់រចនាសម្ព័ន្ធកាន់តែច្រើនដែលយើងពណ៌នា ថ្នាក់ និងថ្នាំងមានកាន់តែច្រើននៅក្នុងការបង្ហាញ វានឹងកើនឡើង ហើយវាក្លាយជាការរអាក់រអួលក្នុងការធ្វើការជាមួយ។

លើសពីនេះទៀត មានបញ្ហានៃការប្រើប្រាស់កូដឡើងវិញ - នៅពេលដែលកូដទាំងអស់ស្ថិតនៅក្នុងការបង្ហាញតែមួយ វាពិបាកក្នុងការចែករំលែកកូដនេះជាមួយអ្នកដទៃ។ ដើម្បីដោះស្រាយបញ្ហាទាំងពីរនេះ Puppet មានអង្គភាពមួយហៅថា ម៉ូឌុល។

ម៉ូឌុល - ទាំងនេះគឺជាសំណុំនៃថ្នាក់ និយមន័យ និងអង្គភាពអាយ៉ងផ្សេងទៀតដែលដាក់ក្នុងថតដាច់ដោយឡែកមួយ។ ម្យ៉ាងវិញទៀត ម៉ូឌុលគឺជាបំណែកឯករាជ្យនៃតក្កវិជ្ជាអាយ៉ង។ ឧទាហរណ៍ វាអាចមានម៉ូឌុលសម្រាប់ធ្វើការជាមួយ nginx ហើយវានឹងមានអ្វីដែលត្រូវការសម្រាប់ធ្វើការជាមួយ nginx ឬអាចមានម៉ូឌុលសម្រាប់ធ្វើការជាមួយ PHP ហើយដូច្នេះនៅលើ។

ម៉ូឌុលត្រូវបានកំណែ ហើយភាពអាស្រ័យនៃម៉ូឌុលនៅលើគ្នាទៅវិញទៅមកក៏ត្រូវបានគាំទ្រផងដែរ។ មានឃ្លាំងបើកចំហនៃម៉ូឌុល - អាយ៉ង Forge.

នៅលើម៉ាស៊ីនមេ អាយ៉ង ម៉ូឌុលមានទីតាំងនៅក្នុងថតរងម៉ូឌុលនៃថតឫស។ នៅខាងក្នុងម៉ូឌុលនីមួយៗមានគ្រោងការណ៍ថតស្តង់ដារ - ការបង្ហាញឯកសារ គំរូ lib និងអ្វីៗផ្សេងទៀត។

រចនាសម្ព័ន្ធឯកសារនៅក្នុងម៉ូឌុល

ឫសនៃម៉ូឌុលអាចមានថតខាងក្រោមដែលមានឈ្មោះពិពណ៌នា៖

• manifests - វាមាន manifestos
• files - វាមានឯកសារ
• templates - វាមានគំរូ
• lib - វាមានលេខកូដ Ruby

នេះមិនមែនជាបញ្ជីពេញលេញនៃថត និងឯកសារនោះទេ ប៉ុន្តែវាគ្រប់គ្រាន់សម្រាប់អត្ថបទនេះសម្រាប់ពេលនេះ។

ឈ្មោះធនធាន និងឈ្មោះឯកសារក្នុងម៉ូឌុល

ឯកសារនៅទីនេះ។

ធនធាន (ថ្នាក់ និយមន័យ) ក្នុងម៉ូឌុលមិនអាចដាក់ឈ្មោះអ្វីដែលអ្នកចូលចិត្តបានទេ។ លើសពីនេះ មានការឆ្លើយឆ្លងដោយផ្ទាល់រវាងឈ្មោះនៃធនធាន និងឈ្មោះនៃឯកសារដែល Puppet នឹងស្វែងរកការពិពណ៌នាអំពីធនធាននោះ។ ប្រសិនបើអ្នកបំពានច្បាប់ដាក់ឈ្មោះ នោះ Puppet នឹងមិនស្វែងរកការពិពណ៌នាធនធានទេ ហើយអ្នកនឹងទទួលបានកំហុសក្នុងការចងក្រង។

ច្បាប់គឺសាមញ្ញ៖

• ធនធានទាំងអស់នៅក្នុងម៉ូឌុលត្រូវតែស្ថិតនៅក្នុងចន្លោះឈ្មោះម៉ូឌុល។ ប្រសិនបើម៉ូឌុលត្រូវបានហៅ 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 - វាទទួលអត្ថបទគំរូជាការបញ្ចូល មិនមែនឈ្មោះឯកសារទេ។

នៅក្នុងគំរូ អ្នកអាចប្រើអថេរ Puppet ទាំងអស់ក្នុងវិសាលភាពបច្ចុប្បន្ន។

អាយ៉ងគាំទ្រគំរូក្នុងទម្រង់ ERB និង EPP៖

• ឯកសារ EPP ។
• ឯកសារ ERB ។

ដោយសង្ខេបអំពី ERB

រចនាសម្ព័ន្ធត្រួតពិនិត្យ៖

• <%= ВЫРАЖЕНИЕ %> - បញ្ចូលតម្លៃនៃកន្សោម
• <% ВЫРАЖЕНИЕ %> - គណនាតម្លៃនៃកន្សោម (ដោយមិនបញ្ចូលវា)។ សេចក្តីថ្លែងការណ៍តាមលក្ខខណ្ឌ (ប្រសិនបើ) និងរង្វិលជុំ (នីមួយៗ) ជាធម្មតាទៅទីនេះ។
• <%# КОММЕНТАРИЙ %>

កន្សោមនៅក្នុង ERB ត្រូវបានសរសេរជា Ruby (ERB គឺពិតជាបង្កប់ Ruby)។

ដើម្បីចូលប្រើអថេរពី manifest អ្នកត្រូវបន្ថែម @ ទៅឈ្មោះអថេរ។ ដើម្បីលុបការបំបែកបន្ទាត់ដែលលេចឡើងបន្ទាប់ពីការសាងសង់វត្ថុបញ្ជា អ្នកត្រូវប្រើស្លាកបិទ -%>.

ឧទាហរណ៍នៃការប្រើប្រាស់គំរូ

ឧបមាថាខ្ញុំកំពុងសរសេរម៉ូឌុលដើម្បីគ្រប់គ្រង ZooKeeper ។ ថ្នាក់ដែលទទួលខុសត្រូវក្នុងការបង្កើត config មើលទៅដូចនេះ៖

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 -%>

ការពិត និងអថេរដែលភ្ជាប់មកជាមួយ

ជាញឹកញាប់ផ្នែកជាក់លាក់នៃការកំណត់អាស្រ័យលើអ្វីដែលកំពុងកើតឡើងនៅលើថ្នាំង។ ឧទាហរណ៍ អាស្រ័យលើការចេញផ្សាយរបស់ Debian អ្នកត្រូវដំឡើងកំណែមួយ ឬមួយផ្សេងទៀតនៃកញ្ចប់។ អ្នកអាចត្រួតពិនិត្យទាំងអស់នេះដោយដៃ ដោយសរសេរសារឡើងវិញ ប្រសិនបើថ្នាំងផ្លាស់ប្តូរ។ ប៉ុន្តែនេះមិនមែនជាវិធីសាស្រ្តធ្ងន់ធ្ងរទេ ស្វ័យប្រវត្តិកម្មគឺប្រសើរជាង។

ដើម្បីទទួលបានព័ត៌មានអំពីថ្នាំង Puppet មានយន្តការហៅថាការពិត។ អង្គហេតុ - នេះគឺជាព័ត៌មានអំពីថ្នាំងដែលមាននៅក្នុង manifests ក្នុងទម្រង់ជាអថេរធម្មតានៅក្នុង namespace សកល។ ឧទាហរណ៍ ឈ្មោះម៉ាស៊ីន កំណែប្រព័ន្ធប្រតិបត្តិការ ស្ថាបត្យកម្មដំណើរការ បញ្ជីអ្នកប្រើប្រាស់ បញ្ជីចំណុចប្រទាក់បណ្តាញ និងអាសយដ្ឋានរបស់ពួកគេ និងច្រើនទៀត។ ការពិតមាននៅក្នុង manifests និង templates ជាអថេរធម្មតា។

ឧទាហរណ៍នៃការធ្វើការជាមួយការពិត៖

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

និយាយជាផ្លូវការ ការពិតមួយមានឈ្មោះ (ខ្សែអក្សរ) និងតម្លៃមួយ (ប្រភេទផ្សេងៗមាន៖ ខ្សែអក្សរ អារេ វចនានុក្រម)។ បរិភោគ សំណុំនៃអង្គហេតុដែលមានស្រាប់. អ្នកក៏អាចសរសេរដោយខ្លួនឯងបានដែរ។ អ្នកប្រមូលការពិតត្រូវបានពិពណ៌នា ដូចជាមុខងារនៅក្នុង Rubyឬរបៀប ឯកសារដែលអាចប្រតិបត្តិបាន។. ការពិតក៏អាចត្រូវបានបង្ហាញជាទម្រង់ផងដែរ។ ឯកសារអត្ថបទជាមួយទិន្នន័យ នៅលើថ្នាំង។

ក្នុងអំឡុងពេលប្រតិបត្តិការ ភ្នាក់ងារអាយ៉ងដំបូងចម្លងអ្នកប្រមូលការពិតដែលមានទាំងអស់ពី pappetserver ទៅកាន់ថ្នាំង បន្ទាប់មកវាបើកដំណើរការពួកវា ហើយផ្ញើការពិតដែលប្រមូលបានទៅម៉ាស៊ីនមេ។ បន្ទាប់ពីនេះ ម៉ាស៊ីនមេចាប់ផ្តើមចងក្រងកាតាឡុក។

ការពិតនៅក្នុងទម្រង់នៃឯកសារដែលអាចប្រតិបត្តិបាន។

ការពិតបែបនេះត្រូវបានដាក់នៅក្នុងម៉ូឌុលនៅក្នុងថត facts.d. ជាការពិតណាស់ ឯកសារត្រូវតែអាចប្រតិបត្តិបាន។ នៅពេលដំណើរការ ពួកគេត្រូវតែបញ្ចេញព័ត៌មានទៅជាលទ្ធផលស្តង់ដារជាទម្រង់ YAML ឬ key=value format។

កុំភ្លេចថាការពិតអនុវត្តចំពោះថ្នាំងទាំងអស់ដែលត្រូវបានគ្រប់គ្រងដោយម៉ាស៊ីនមេ poppet ដែលម៉ូឌុលរបស់អ្នកត្រូវបានដាក់ពង្រាយ។ ដូច្នេះនៅក្នុងស្គ្រីប សូមយកចិត្តទុកដាក់ពិនិត្យមើលថាប្រព័ន្ធមានកម្មវិធី និងឯកសារទាំងអស់ដែលចាំបាច់សម្រាប់ការពិតរបស់អ្នកដើម្បីដំណើរការ។

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

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

ការពិត Ruby

ការពិតបែបនេះត្រូវបានដាក់នៅក្នុងម៉ូឌុលនៅក្នុងថត 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).

នេះគឺជាផ្នែកពាក់ព័ន្ធនៃឯកសារ។

អថេរដែលភ្ជាប់មកជាមួយ

ក្រៅពីការពិតក៏មានដែរ។ អថេរមួយចំនួនមាននៅក្នុង namespace សកល។

• អង្គហេតុដែលអាចទុកចិត្តបាន។ — អថេរ​ដែល​ត្រូវ​បាន​យក​ចេញ​ពី​វិញ្ញាបនបត្រ​របស់​អតិថិជន (ចាប់តាំងពី​វិញ្ញាបនបត្រ​ត្រូវ​បាន​ចេញ​ជា​ធម្មតា​នៅ​លើ​ម៉ាស៊ីន​បម្រើ poppet ភ្នាក់ងារ​មិន​អាច​គ្រាន់​តែ​យក​និង​ផ្លាស់​ប្តូ​រ​វិញ្ញាបនបត្រ​របស់​ខ្លួន​ដូច្នេះ​អថេរ​ត្រូវ​បាន "ទុកចិត្ត"): ឈ្មោះ​នៃ​វិញ្ញាបនបត្រ ឈ្មោះ​របស់ ម៉ាស៊ីន និងដែន ផ្នែកបន្ថែមពីវិញ្ញាបនបត្រ។
• ការពិតរបស់ម៉ាស៊ីនមេ -អថេរ​ទាក់ទង​នឹង​ព័ត៌មាន​អំពី​ម៉ាស៊ីន​មេ—កំណែ ឈ្មោះ អាសយដ្ឋាន IP ម៉ាស៊ីន​បម្រើ បរិស្ថាន។
• ការពិតភ្នាក់ងារ — អថេរបន្ថែមដោយផ្ទាល់ដោយភ្នាក់ងារអាយ៉ង និងមិនមែនដោយការពិត — ឈ្មោះវិញ្ញាបនបត្រ កំណែភ្នាក់ងារ កំណែអាយ៉ង។
• អថេរមេ - អថេរ Pappetmaster (sic!) វាគឺអំពីដូចគ្នានឹងនៅក្នុង ការពិតរបស់ម៉ាស៊ីនមេ, បូកតម្លៃប៉ារ៉ាម៉ែត្រកំណត់រចនាសម្ព័ន្ធគឺអាចរកបាន។
• អថេរចងក្រង - អថេរចងក្រងដែលខុសគ្នាក្នុងវិសាលភាពនីមួយៗ៖ ឈ្មោះនៃម៉ូឌុលបច្ចុប្បន្ន និងឈ្មោះរបស់ម៉ូឌុលដែលវត្ថុបច្ចុប្បន្នត្រូវបានចូលប្រើ។ ពួកវាអាចត្រូវបានប្រើជាឧទាហរណ៍ ដើម្បីពិនិត្យមើលថាថ្នាក់ឯកជនរបស់អ្នកមិនត្រូវបានប្រើដោយផ្ទាល់ពីម៉ូឌុលផ្សេងទៀតទេ។

បន្ថែម 1: របៀបដំណើរការនិងបំបាត់កំហុសទាំងអស់នេះ?

អត្ថបទមានឧទាហរណ៍ជាច្រើននៃកូដអាយ៉ង ប៉ុន្តែមិនបានប្រាប់យើងពីរបៀបដំណើរការកូដនេះទាល់តែសោះ។ អញ្ចឹងខ្ញុំកែខ្លួនឯងហើយ។

ភ្នាក់ងារគឺគ្រប់គ្រាន់ដើម្បីដំណើរការ Puppet ប៉ុន្តែសម្រាប់ករណីភាគច្រើន អ្នកក៏នឹងត្រូវការម៉ាស៊ីនមេផងដែរ។

ភ្នាក់ងារ

យ៉ាងហោចណាស់ចាប់តាំងពីកំណែទី 5 កញ្ចប់អាយ៉ងភ្នាក់ងារពី ឃ្លាំង Puppetlabs ផ្លូវការ ផ្ទុកនូវភាពអាស្រ័យទាំងអស់ (ត្បូងទទឹម និងត្បូងដែលត្រូវគ្នា) ដូច្នេះមិនមានការលំបាកក្នុងការដំឡើងទេ (ខ្ញុំកំពុងនិយាយអំពីការចែកចាយដែលមានមូលដ្ឋានលើ Debian - យើងមិនប្រើការចែកចាយដែលមានមូលដ្ឋានលើ 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.

ម៉ាស៊ីនមេ

ខ្ញុំនឹងមិនពិចារណាអំពីការដំឡើងពេញលេញនៃ pappetserver និងការដាក់ពង្រាយកូដទៅវានៅក្នុងអត្ថបទនេះទេ ខ្ញុំនឹងនិយាយថាចេញពីប្រអប់មានកំណែមុខងារពេញលេញនៃម៉ាស៊ីនមេដែលមិនត្រូវការការកំណត់បន្ថែមដើម្បីធ្វើការជាមួយចំនួនតូចមួយនៃ ថ្នាំង (និយាយរហូតដល់មួយរយ) ។ ថ្នាំងមួយចំនួនធំនឹងតម្រូវឱ្យមានការលៃតម្រូវ - តាមលំនាំដើម ម៉ាស៊ីនមេអាយ៉ងបើកដំណើរការមិនលើសពីកម្មករបួននាក់ ដើម្បីដំណើរការកាន់តែច្រើន អ្នកត្រូវបង្កើនចំនួនរបស់ពួកគេ ហើយកុំភ្លេចបង្កើនដែនកំណត់អង្គចងចាំ បើមិនដូច្នេះទេម៉ាស៊ីនមេនឹងប្រមូលសំរាមភាគច្រើន។

ការដាក់ពង្រាយកូដ - ប្រសិនបើអ្នកត្រូវការវាលឿន និងងាយស្រួល បន្ទាប់មកមើល (នៅ r10k)[https://github.com/puppetlabs/r10k] សម្រាប់ការដំឡើងតូចៗវាគួរតែគ្រប់គ្រាន់ហើយ។

ឧបសម្ព័ន្ធទី 2៖ ការណែនាំអំពីការសរសេរកូដ

1. ដាក់តក្កវិជ្ជាទាំងអស់នៅក្នុងថ្នាក់ និងនិយមន័យ។
2. រក្សាថ្នាក់ និងនិយមន័យនៅក្នុងម៉ូឌុល មិនមែននៅក្នុង manifests ដែលពិពណ៌នាអំពីថ្នាំងទេ។
3. ប្រើការពិត។
4. កុំបង្កើត ifs ដោយផ្អែកលើឈ្មោះម៉ាស៊ីន។
5. មានអារម្មណ៍សេរីក្នុងការបន្ថែមប៉ារ៉ាម៉ែត្រសម្រាប់ថ្នាក់ និងនិយមន័យ - នេះប្រសើរជាងតក្កវិជ្ជាដែលលាក់នៅក្នុងតួនៃថ្នាក់/កំណត់។

ខ្ញុំនឹងពន្យល់ពីមូលហេតុដែលខ្ញុំណែនាំអោយធ្វើបែបនេះនៅក្នុងអត្ថបទបន្ទាប់។

សេចក្តីសន្និដ្ឋាន

សូមបញ្ចប់ជាមួយនឹងការណែនាំ។ នៅក្នុងអត្ថបទបន្ទាប់ខ្ញុំនឹងប្រាប់អ្នកអំពី Hiera, ENC និង PuppetDB ។

មានតែអ្នកប្រើប្រាស់ដែលបានចុះឈ្មោះប៉ុណ្ណោះដែលអាចចូលរួមក្នុងការស្ទង់មតិនេះ។ ចូលសូម។

តាមពិតមានសម្ភារៈជាច្រើនទៀត - ខ្ញុំអាចសរសេរអត្ថបទលើប្រធានបទខាងក្រោម បោះឆ្នោតលើអ្វីដែលអ្នកចង់អានអំពី៖

• 59,1%សំណង់អាយ៉ងកម្រិតខ្ពស់ - កម្រិតបន្ទាប់មួយចំនួន៖ រង្វិលជុំ ការធ្វើផែនទី និងកន្សោម lambda ផ្សេងទៀត អ្នកប្រមូលធនធាន ធនធានដែលបាននាំចេញ និងការទំនាក់ទំនងអន្តរម៉ាស៊ីនតាមរយៈអាយ៉ង ស្លាក អ្នកផ្តល់សេវា ប្រភេទទិន្នន័យអរូបី។13
• 31,8%"ខ្ញុំជាអ្នកគ្រប់គ្រងរបស់ម្តាយខ្ញុំ" ឬរបៀបដែលយើងនៅក្នុង Avito បង្កើតមិត្តជាមួយម៉ាស៊ីនមេ poppet ជាច្រើននៃកំណែផ្សេងៗគ្នា ហើយជាគោលការណ៍ផ្នែកអំពីការគ្រប់គ្រងម៉ាស៊ីនមេ poppet.7
• 81,8%របៀបដែលយើងសរសេរកូដអាយ៉ង៖ ឧបករណ៍ ឯកសារ ការធ្វើតេស្ត CI/CD.18

អ្នកប្រើប្រាស់ 22 នាក់បានបោះឆ្នោត។ អ្នកប្រើប្រាស់ ៧៨ នាក់ត្រូវបានហាមឃាត់។

ប្រភព: www.habr.com