પપેટ એ રૂપરેખાંકન વ્યવસ્થાપન સિસ્ટમ છે. તેનો ઉપયોગ યજમાનોને ઇચ્છિત સ્થિતિમાં લાવવા અને આ સ્થિતિ જાળવવા માટે થાય છે.

હું હવે પાંચ વર્ષથી પપેટ સાથે કામ કરી રહ્યો છું. આ ટેક્સ્ટ અનિવાર્યપણે સત્તાવાર દસ્તાવેજીકરણમાંથી મુખ્ય મુદ્દાઓનું ભાષાંતરિત અને પુનઃક્રમાંકિત સંકલન છે, જે નવા નિશાળીયાને પપેટના સારને ઝડપથી સમજવાની મંજૂરી આપશે.

મૂળભૂત માહિતી

પપેટની ઓપરેટિંગ સિસ્ટમ ક્લાયંટ-સર્વર છે, જો કે તે મર્યાદિત કાર્યક્ષમતા સાથે સર્વરલેસ ઓપરેશનને પણ સપોર્ટ કરે છે.

ઑપરેશનના પુલ મૉડલનો ઉપયોગ કરવામાં આવે છે: ડિફૉલ્ટ રૂપે, દર અડધા કલાકમાં એકવાર, ક્લાયંટ રૂપરેખાંકન માટે સર્વરનો સંપર્ક કરે છે અને તેને લાગુ કરે છે. જો તમે Ansible સાથે કામ કર્યું છે, તો પછી તેઓ એક અલગ પુશ મોડેલનો ઉપયોગ કરે છે: એડમિનિસ્ટ્રેટર રૂપરેખાંકન લાગુ કરવાની પ્રક્રિયા શરૂ કરે છે, ક્લાયંટ પોતે કંઈપણ લાગુ કરશે નહીં.

નેટવર્ક કમ્યુનિકેશન દરમિયાન, દ્વિ-માર્ગી TLS એન્ક્રિપ્શનનો ઉપયોગ થાય છે: સર્વર અને ક્લાયંટ પાસે તેમની પોતાની ખાનગી કીઓ અને અનુરૂપ પ્રમાણપત્રો હોય છે. સામાન્ય રીતે સર્વર ગ્રાહકો માટે પ્રમાણપત્રો જારી કરે છે, પરંતુ સૈદ્ધાંતિક રીતે બાહ્ય CA નો ઉપયોગ કરવો શક્ય છે.

મેનિફેસ્ટોનો પરિચય

В терминологии Puppet કઠપૂતળી સર્વર માટે જોડાવા ગાંઠો (ગાંઠો). નોડ્સ માટે રૂપરેખાંકન લખાયેલ છે મેનિફેસ્ટોમાં ખાસ પ્રોગ્રામિંગ ભાષામાં - પપેટ ડીએસએલ.

પપેટ ડીએસએલ એ ઘોષણાત્મક ભાષા છે. તે વ્યક્તિગત સંસાધનોની ઘોષણાઓના સ્વરૂપમાં નોડની ઇચ્છિત સ્થિતિનું વર્ણન કરે છે, ઉદાહરણ તરીકે:

• ફાઇલ અસ્તિત્વમાં છે અને તેમાં ચોક્કસ સામગ્રી છે.
• પેકેજ ઇન્સ્ટોલ કરેલું છે.
• સેવા શરૂ થઈ ગઈ છે.

સંસાધનો એકબીજા સાથે જોડાયેલા હોઈ શકે છે:

• ત્યાં અવલંબન છે, તેઓ સંસાધનોનો ઉપયોગ કરવામાં આવે છે તે ક્રમને અસર કરે છે.
  ઉદાહરણ તરીકે, "પહેલા પેકેજ ઇન્સ્ટોલ કરો, પછી રૂપરેખાંકન ફાઇલમાં ફેરફાર કરો, પછી સેવા શરૂ કરો."
• ત્યાં સૂચનાઓ છે - જો કોઈ સંસાધન બદલાયું હોય, તો તે તેના પર સબ્સ્ક્રાઇબ કરેલા સંસાધનોને સૂચનાઓ મોકલે છે.
  ઉદાહરણ તરીકે, જો રૂપરેખાંકન ફાઇલ બદલાય છે, તો તમે આપમેળે સેવાને પુનઃપ્રારંભ કરી શકો છો.

વધુમાં, પપેટ ડીએસએલમાં કાર્યો અને ચલો, તેમજ શરતી નિવેદનો અને પસંદગીકારો છે. વિવિધ ટેમ્પલેટીંગ મિકેનિઝમ્સ પણ સપોર્ટેડ છે - 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 }).
• પરિમાણો પરના તીરો સમાન સ્તર પર હોવા જોઈએ.
• તેમની આગળ સંસાધન સંબંધ તીર લખાયેલ છે.

પેપેટસર્વર પર ફાઇલોનું સ્થાન

વધુ સમજૂતી માટે, હું "રુટ ડિરેક્ટરી" નો ખ્યાલ રજૂ કરીશ. રુટ ડિરેક્ટરી એ ડિરેક્ટરી છે જે ચોક્કસ નોડ માટે પપેટ રૂપરેખાંકન ધરાવે છે.

રૂટ ડિરેક્ટરી પપેટના સંસ્કરણ અને ઉપયોગમાં લેવાતા વાતાવરણના આધારે બદલાય છે. પર્યાવરણ એ રૂપરેખાંકનના સ્વતંત્ર સેટ છે જે અલગ ડિરેક્ટરીઓમાં સંગ્રહિત થાય છે. સામાન્ય રીતે ગિટ સાથે સંયોજનમાં વપરાય છે, જે કિસ્સામાં ગિટ શાખાઓમાંથી વાતાવરણ બનાવવામાં આવે છે. તદનુસાર, દરેક નોડ એક અથવા બીજા વાતાવરણમાં સ્થિત છે. આ નોડ પર જ અથવા 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 માંથી ફાઇલનો ઉપયોગ કરવામાં આવશે)
• લક્ષ્ય — જ્યાં સિમલિંક નિર્દેશ કરે છે (સાથે સાથે ઉપયોગ કરી શકાતો નથી સામગ્રી અથવા સ્ત્રોત)
• માલિક - વપરાશકર્તા કે જેની પાસે ફાઇલ હોવી જોઈએ
• જૂથ — જે જૂથની ફાઈલ હોવી જોઈએ
• સ્થિતિ - ફાઇલ પરવાનગીઓ (સ્ટ્રિંગ તરીકે)
• પુનરાવર્તન - પુનરાવર્તિત ડિરેક્ટરી પ્રક્રિયાને સક્ષમ કરે છે
• શુધ્ધીકરણ - પપેટમાં વર્ણવેલ ન હોય તેવી ફાઇલોને કાઢી નાખવા સક્ષમ કરે છે
• બળ - પપેટમાં વર્ણવેલ ન હોય તેવી ડિરેક્ટરીઓ કાઢી નાખવાને સક્ષમ કરે છે

પેકેજ

પેકેજો ઇન્સ્ટોલ કરે છે અને દૂર કરે છે. સૂચનાઓને હેન્ડલ કરવામાં સક્ષમ - જો પેરામીટર સ્પષ્ટ કરેલ હોય તો પેકેજ પુનઃસ્થાપિત કરે છે refresh_on_reinstall.

પરિમાણો:

• название ресурса - પેકેજ નામ (વૈકલ્પિક)
• નામ - પેકેજનું નામ (જો નામમાં ઉલ્લેખિત ન હોય તો)
• પ્રદાતા - વાપરવા માટે પેકેજ મેનેજર
• ખાતરી - પેકેજની ઇચ્છિત સ્થિતિ:
  • present, installed - કોઈપણ સંસ્કરણ ઇન્સ્ટોલ કરેલું છે
  • latest - નવીનતમ સંસ્કરણ ઇન્સ્ટોલ કર્યું
  • absent - કાઢી નાખ્યું (apt-get remove)
  • purged — રૂપરેખાંકન ફાઇલો સાથે કાઢી નાખેલ (apt-get purge)
  • held - પેકેજ સંસ્કરણ લૉક થયેલ છે (apt-mark hold)
  • любая другая строка - ઉલ્લેખિત સંસ્કરણ ઇન્સ્ટોલ કરેલું છે
• refresh_on_reinstall - જો true, પછી સૂચના પ્રાપ્ત થયા પછી પેકેજ ફરીથી ઇન્સ્ટોલ કરવામાં આવશે. સ્ત્રોત-આધારિત વિતરણો માટે ઉપયોગી છે, જ્યાં બિલ્ડ પરિમાણો બદલતી વખતે પેકેજો પુનઃનિર્માણ જરૂરી હોઈ શકે છે. ડિફૉલ્ટ false.

સેવા

સેવાઓનું સંચાલન કરે છે. સૂચનાઓ પર પ્રક્રિયા કરવામાં સક્ષમ - સેવા પુનઃપ્રારંભ કરે છે.

પરિમાણો:

• название ресурса - મેનેજ કરવાની સેવા (વૈકલ્પિક)
• નામ - સેવા કે જેનું સંચાલન કરવાની જરૂર છે (જો નામમાં ઉલ્લેખિત ન હોય તો)
• ખાતરી - સેવાની ઇચ્છિત સ્થિતિ:
  • running - શરૂ
  • stopped - બંધ
• સક્ષમ કરો - સેવા શરૂ કરવાની ક્ષમતાને નિયંત્રિત કરે છે:
  • true - ઓટોરન સક્ષમ છે (systemctl enable)
  • mask - વેશમાં (systemctl mask)
  • false - ઓટોરન અક્ષમ છે (systemctl disable)
• પુનઃપ્રારંભ - સેવા પુનઃપ્રારંભ કરવાનો આદેશ
• સ્થિતિ - સેવાની સ્થિતિ તપાસવાનો આદેશ
• hasrestart — સૂચવો કે શું સેવા initscript પુનઃશરૂ કરવાનું આધાર આપે છે. જો false અને પરિમાણ સ્પષ્ટ થયેલ છે પુનઃપ્રારંભ — આ પરિમાણની કિંમત વપરાય છે. જો false и параметр પુનઃપ્રારંભ ઉલ્લેખિત નથી - સેવા બંધ થઈ ગઈ છે અને પુનઃપ્રારંભ કરવાનું શરૂ કર્યું છે (પરંતુ systemd આદેશનો ઉપયોગ કરે છે systemctl restart).
• સ્ટેટસ — સૂચવો કે શું સેવા initscript આદેશને આધાર આપે છે status. જો false, પછી પરિમાણ મૂલ્યનો ઉપયોગ થાય છે સ્થિતિ. ડિફૉલ્ટ true.

exec

બાહ્ય આદેશો ચલાવે છે. જો તમે પરિમાણોનો ઉલ્લેખ કરતા નથી બનાવે છે, માત્ર જો, સિવાય અથવા તાજગીથી, આદેશ દર વખતે પપેટ ચલાવવામાં આવશે. સૂચનાઓ પર પ્રક્રિયા કરવામાં સક્ષમ - આદેશ ચલાવે છે.

પરિમાણો:

• название ресурса - ચલાવવાનો આદેશ (વૈકલ્પિક)
• આદેશ - ચલાવવાનો આદેશ (જો તે નામમાં ઉલ્લેખિત ન હોય તો)
• પાથ — પાથ કે જેમાં એક્ઝેક્યુટેબલ ફાઇલને જોવાની છે
• માત્ર જો — જો આ પરિમાણમાં ઉલ્લેખિત આદેશ શૂન્ય રીટર્ન કોડ સાથે પૂર્ણ થાય, તો મુખ્ય આદેશ ચલાવવામાં આવશે.
• સિવાય — જો આ પરિમાણમાં ઉલ્લેખિત આદેશ બિન-શૂન્ય રીટર્ન કોડ સાથે પૂર્ણ થાય, તો મુખ્ય આદેશ ચલાવવામાં આવશે.
• બનાવે છે — જો આ પરિમાણમાં ઉલ્લેખિત ફાઇલ અસ્તિત્વમાં ન હોય, તો મુખ્ય આદેશ ચલાવવામાં આવશે
• તાજગીથી - જો true, તો આદેશ ફક્ત ત્યારે જ ચલાવવામાં આવશે જ્યારે આ exec અન્ય સ્રોતોમાંથી સૂચના મેળવે
• cwd — директория, из которой запускать команду
• વપરાશકર્તા — વપરાશકર્તા જેની પાસેથી આદેશ ચલાવવાનો છે
• પ્રદાતા - આદેશ કેવી રીતે ચલાવવો:
  • પોક્સિક્સ — બાળ પ્રક્રિયા સરળ રીતે બનાવવામાં આવે છે, સ્પષ્ટ કરવાની ખાતરી કરો પાથ
  • શેલ - આદેશ શેલમાં શરૂ થાય છે /bin/sh, ઉલ્લેખિત ન હોઈ શકે પાથ, તમે ગ્લોબિંગ, પાઇપ્સ અને અન્ય શેલ સુવિધાઓનો ઉપયોગ કરી શકો છો. જો કોઈ વિશિષ્ટ અક્ષરો હોય તો સામાન્ય રીતે આપમેળે શોધાય છે (|, ;, &&, || વગેરે).

ક્રોન

ક્રોનજોબ્સને નિયંત્રિત કરે છે.

પરિમાણો:

• название ресурса - માત્ર અમુક પ્રકારનો ઓળખકર્તા
• ખાતરી - તાજ જોબ સ્થિતિ:
  • present - જો અસ્તિત્વમાં ન હોય તો બનાવો
  • absent - જો અસ્તિત્વમાં હોય તો કાઢી નાખો
• આદેશ - કયો આદેશ ચલાવવો
• પર્યાવરણ - કયા વાતાવરણમાં આદેશ ચલાવવાનો છે (પર્યાવરણ ચલોની સૂચિ અને તેમના મૂલ્યો દ્વારા =)
• વપરાશકર્તા - કયા વપરાશકર્તા પાસેથી આદેશ ચલાવવાનો છે
• મિનિટ, કલાક, સાપ્તાહિક, માસ, મહિનાનો દિવસ - ક્રોન ક્યારે ચલાવવું. જો આમાંની કોઈપણ વિશેષતાઓ ઉલ્લેખિત નથી, તો ક્રૉન્ટાબમાં તેનું મૂલ્ય હશે *.

В Puppet 6.0 ક્રોન જાણે કે બોક્સમાંથી દૂર કરવામાં આવે છે puppetserver માં, તેથી સામાન્ય સાઇટ પર કોઈ દસ્તાવેજ નથી. પણ તે બોક્સમાં છે કઠપૂતળી-એજન્ટમાં, તેથી તેને અલગથી ઇન્સ્ટોલ કરવાની જરૂર નથી. તમે તેના માટે દસ્તાવેજીકરણ જોઈ શકો છો в документации к пятой версии Паппета, અથવા на Гитхабе.

સામાન્ય રીતે સંસાધનો વિશે

સંસાધન વિશિષ્ટતા માટેની આવશ્યકતાઓ

સૌથી સામાન્ય ભૂલ આપણે અનુભવીએ છીએ ડુપ્લિકેટ ઘોષણા. આ ભૂલ ત્યારે થાય છે જ્યારે નિર્દેશિકામાં સમાન નામ સાથે સમાન પ્રકારનાં બે અથવા વધુ સંસાધનો દેખાય છે.

Поэтому ещё раз напишу: સમાન નોડ માટે મેનિફેસ્ટમાં સમાન શીર્ષક સાથે સમાન પ્રકારના સંસાધનો ન હોવા જોઈએ!

કેટલીકવાર સમાન નામ સાથે પેકેજો ઇન્સ્ટોલ કરવાની જરૂર હોય છે, પરંતુ વિવિધ પેકેજ મેનેજર સાથે. આ કિસ્સામાં, તમારે પરિમાણનો ઉપયોગ કરવાની જરૂર છે nameભૂલ ટાળવા માટે:

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

અન્ય સંસાધન પ્રકારો પાસે ડુપ્લિકેશન ટાળવા માટે સમાન વિકલ્પો છે - name у સેવા, command у exec, и так далее.

મેટાપેરામીટર્સ

દરેક સંસાધન પ્રકાર તેની પ્રકૃતિને ધ્યાનમાં લીધા વિના કેટલાક વિશિષ્ટ પરિમાણો ધરાવે છે.

મેટા પરિમાણોની સંપૂર્ણ સૂચિ પપેટ દસ્તાવેજીકરણમાં.

ટૂંકી સૂચિ:

• જરૂર — આ પરિમાણ સૂચવે છે કે આ સ્ત્રોત કયા સ્ત્રોતો પર આધાર રાખે છે.
• પહેલાં - આ પરિમાણ સ્પષ્ટ કરે છે કે કયા સંસાધનો આ સંસાધન પર આધાર રાખે છે.
• ઉમેદવારી નોંધાવવા — આ પરિમાણ સ્પષ્ટ કરે છે કે આ સ્ત્રોત કયા સ્ત્રોતોમાંથી સૂચનાઓ મેળવે છે.
• સૂચિત — આ પરિમાણ સ્પષ્ટ કરે છે કે કયા સ્ત્રોતો આ સ્ત્રોતમાંથી સૂચનાઓ મેળવે છે.

સૂચિબદ્ધ તમામ મેટાપેરામીટર્સ કાં તો એક રિસોર્સ લિંક અથવા ચોરસ કૌંસમાં લિંક્સની શ્રેણી સ્વીકારે છે.

સંસાધનોની લિંક્સ

સંસાધન લિંક એ ફક્ત સંસાધનનો ઉલ્લેખ છે. તેઓ મુખ્યત્વે નિર્ભરતા દર્શાવવા માટે વપરાય છે. અસ્તિત્વમાં ન હોય તેવા સંસાધનનો સંદર્ભ આપવાથી સંકલન ભૂલ થશે.

લિંકનું વાક્યરચના નીચે મુજબ છે: મોટા અક્ષર સાથે સંસાધન પ્રકાર (જો પ્રકાર નામમાં ડબલ કોલોન હોય, તો કોલોન્સ વચ્ચેના નામના દરેક ભાગને કેપિટલાઇઝ કરવામાં આવે છે), પછી ચોરસ કૌંસમાં સંસાધનનું નામ (નામનો કેસ) બદલાતું નથી!). ત્યાં કોઈ જગ્યા હોવી જોઈએ નહીં; ચોરસ કૌંસ ટાઇપના નામ પછી તરત જ લખવામાં આવે છે.

ઉદાહરણ:

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

નિર્ભરતા અને સૂચનાઓ

અહીં દસ્તાવેજીકરણ.

અગાઉ કહ્યું તેમ, સંસાધનો વચ્ચેની સરળ અવલંબન સંક્રમણકારી છે. માર્ગ દ્વારા, નિર્ભરતા ઉમેરતી વખતે સાવચેત રહો - તમે ચક્રીય અવલંબન બનાવી શકો છો, જે સંકલન ભૂલનું કારણ બનશે.

અવલંબનથી વિપરીત, સૂચનાઓ સંક્રમિત નથી. સૂચનાઓ માટે નીચેના નિયમો લાગુ પડે છે:

• જો સંસાધનને સૂચના મળે છે, તો તે અપડેટ થાય છે. અપડેટ ક્રિયાઓ સંસાધન પ્રકાર - પર આધાર રાખે છે exec આદેશ ચલાવે છે, સેવા સેવા ફરી શરૂ કરે છે, પેકેજ પેકેજ પુનઃસ્થાપિત કરે છે. જો સંસાધનમાં અપડેટ ક્રિયા વ્યાખ્યાયિત ન હોય, તો કંઈ થતું નથી.
• પપેટના એક રન દરમિયાન, સંસાધન એક કરતા વધુ વાર અપડેટ થતું નથી. આ શક્ય છે કારણ કે સૂચનાઓમાં અવલંબનનો સમાવેશ થાય છે અને નિર્ભરતા ગ્રાફમાં ચક્ર નથી.
• Если Паппет меняет состояние ресурса, то ресурс отправляет уведомления всем подписанным на него ресурсам.
• જો કોઈ સંસાધન અપડેટ કરવામાં આવે છે, તો તે તેના પર સબ્સ્ક્રાઇબ કરેલ તમામ સંસાધનોને સૂચનાઓ મોકલે છે.

અનિશ્ચિત પરિમાણોને હેન્ડલ કરવું

Как правило, если у какого-то параметра ресурса нет значения по умолчанию и этот параметр не указан в манифесте, то Паппет не будет менять это свойство у соответствующего ресурса на ноде. Например, если у ресурса типа ફાઇલ પરિમાણ ઉલ્લેખિત નથી 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,
) {
  ...
}

વર્ગો: વર્ગનામ વિ વર્ગ{'classname':} શામેલ કરો

દરેક વર્ગ એક પ્રકારનું સાધન છે વર્ગ. Как и в случае с любыми другими типами ресурсов, на одной ноде не может присутствовать два экземпляра одного и того же класса.

Если попробовать добавить класс на одну и ту же ноду два раза с помощью class { 'classname':} (કોઈ તફાવત નથી, અલગ અથવા સમાન પરિમાણો સાથે), સંકલન ભૂલ હશે. પરંતુ જો તમે સંસાધન શૈલીમાં વર્ગનો ઉપયોગ કરો છો, તો તમે તરત જ મેનિફેસ્ટમાં તેના તમામ પરિમાણો સ્પષ્ટપણે સેટ કરી શકો છો.

જો કે, જો તમે ઉપયોગ કરો છો include, પછી વર્ગ ઇચ્છિત તરીકે ઘણી વખત ઉમેરી શકાય છે. હકીકત એ છે કે include એ એક આઇડમ્પોટેન્ટ ફંક્શન છે જે તપાસે છે કે ડિરેક્ટરીમાં ક્લાસ ઉમેરવામાં આવ્યો છે કે નહીં. જો વર્ગ ડિરેક્ટરીમાં નથી, તો તે તેને ઉમેરે છે, અને જો તે પહેલેથી જ અસ્તિત્વમાં છે, તો તે કંઈ કરતું નથી. પરંતુ ઉપયોગના કિસ્સામાં include તમે વર્ગ ઘોષણા દરમિયાન વર્ગ પરિમાણો સેટ કરી શકતા નથી - બધા જરૂરી પરિમાણો બાહ્ય ડેટા સ્ત્રોત - Hiera અથવા ENC માં સેટ હોવા જોઈએ. અમે હવે પછીના લેખમાં તેમના વિશે વાત કરીશું.

વ્યાખ્યાયિત કરે છે

અગાઉના બ્લોકમાં જણાવ્યા મુજબ, એક જ વર્ગ નોડ પર એક કરતા વધુ વખત હાજર રહી શકતો નથી. જો કે, કેટલાક કિસ્સાઓમાં તમારે સમાન નોડ પર વિવિધ પરિમાણો સાથે કોડના સમાન બ્લોકનો ઉપયોગ કરવા માટે સક્ષમ બનવાની જરૂર છે. બીજા શબ્દોમાં કહીએ તો, તેના પોતાના પ્રકારના સંસાધનની જરૂર છે.

ઉદાહરણ તરીકે, PHP મોડ્યુલ ઇન્સ્ટોલ કરવા માટે, અમે Avito માં નીચે મુજબ કરીએ છીએ:

1. આ મોડ્યુલ સાથે પેકેજ ઇન્સ્ટોલ કરો.
2. ચાલો આ મોડ્યુલ માટે રૂપરેખાંકન ફાઈલ બનાવીએ.
3. અમે php-fpm માટે રૂપરેખા માટે સિમલિંક બનાવીએ છીએ.
4. અમે php cli માટે રૂપરેખા માટે સિમલિંક બનાવીએ છીએ.

આવા કિસ્સાઓમાં, જેમ કે ડિઝાઇન વ્યાખ્યાયિત કરો (વ્યાખ્યાયિત, નિર્ધારિત પ્રકાર, નિર્ધારિત સંસાધન પ્રકાર). વ્યાખ્યા એ વર્ગ જેવી જ છે, પરંતુ તેમાં તફાવતો છે: પ્રથમ, દરેક વ્યાખ્યા એ સંસાધન પ્રકાર છે, સંસાધન નથી; બીજું, દરેક વ્યાખ્યામાં ગર્ભિત પરિમાણ હોય છે $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 {
  ...
}

સિવાય

જ્યાં સુધી એક if વિપરીત હોય: જો અભિવ્યક્તિ ખોટી હોય તો કોડનો બ્લોક એક્ઝિક્યુટ કરવામાં આવશે.

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 ફોર્મેટમાં ટેમ્પલેટ્સને સપોર્ટ કરે છે:

• EPP દસ્તાવેજીકરણ.
• ERB દસ્તાવેજીકરણ.

ERB વિશે સંક્ષિપ્તમાં

નિયંત્રણ માળખાં:

• <%= ВЫРАЖЕНИЕ %> - અભિવ્યક્તિનું મૂલ્ય દાખલ કરો
• <% ВЫРАЖЕНИЕ %> - અભિવ્યક્તિના મૂલ્યની ગણતરી કરો (તે દાખલ કર્યા વિના). શરતી નિવેદનો (જો) અને લૂપ્સ (દરેક) સામાન્ય રીતે અહીં જાય છે.
• <%# КОММЕНТАРИЙ %>

ERB માં અભિવ્યક્તિઓ રૂબીમાં લખાયેલ છે (ERB ખરેખર એમ્બેડેડ રૂબી છે).

મેનિફેસ્ટમાંથી ચલોને ઍક્સેસ કરવા માટે, તમારે ઉમેરવાની જરૂર છે @ ચલ નામ માટે. કંટ્રોલ કન્સ્ટ્રક્ટ પછી દેખાતા લાઇન બ્રેકને દૂર કરવા માટે, તમારે ક્લોઝિંગ ટેગનો ઉપયોગ કરવાની જરૂર છે -%>.

નમૂનાનો ઉપયોગ કરવાનું ઉદાહરણ

ચાલો કહીએ કે હું ZooKeeper ને નિયંત્રિત કરવા માટે એક મોડ્યુલ લખી રહ્યો છું. રૂપરેખા બનાવવા માટે જવાબદાર વર્ગ આના જેવો દેખાય છે:

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 просто выводит сообщение в лог

ઔપચારિક રીતે કહીએ તો, હકીકતમાં નામ (સ્ટ્રિંગ) અને મૂલ્ય હોય છે (વિવિધ પ્રકારો ઉપલબ્ધ છે: શબ્દમાળાઓ, એરે, શબ્દકોશ). ખાવું બિલ્ટ-ઇન તથ્યોનો સમૂહ. તમે તમારું પોતાનું પણ લખી શકો છો. હકીકત સંગ્રાહકો વર્ણવેલ છે રૂબી માં કાર્યોની જેમક્યાં તરીકે એક્ઝિક્યુટેબલ ફાઇલો. તથ્યો પણ ફોર્મમાં રજૂ કરી શકાય છે ડેટા સાથે ટેક્સ્ટ ફાઇલો ગાંઠો પર.

ઓપરેશન દરમિયાન, કઠપૂતળી એજન્ટ સૌપ્રથમ પેપેટસર્વરથી નોડ પર ઉપલબ્ધ તમામ તથ્યો સંગ્રહકોની નકલ કરે છે, ત્યારબાદ તે તેમને લોન્ચ કરે છે અને એકત્રિત તથ્યો સર્વરને મોકલે છે; આ પછી, સર્વર કેટલોગનું સંકલન કરવાનું શરૂ કરે છે.

એક્ઝેક્યુટેબલ ફાઇલોના સ્વરૂપમાં હકીકતો

આવા તથ્યો ડિરેક્ટરીમાં મોડ્યુલમાં મૂકવામાં આવે છે 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).

Вот нужный раздел документации.

બિલ્ટ-ઇન વેરીએબલ્સ

હકીકતો ઉપરાંત, ત્યાં પણ છે કેટલાક ચલો, વૈશ્વિક નેમસ્પેસમાં ઉપલબ્ધ છે.

• trusted facts — ચલો જે ક્લાયંટના પ્રમાણપત્રમાંથી લેવામાં આવે છે (કારણ કે પ્રમાણપત્ર સામાન્ય રીતે પોપેટ સર્વર પર જારી કરવામાં આવે છે, એજન્ટ ફક્ત તેનું પ્રમાણપત્ર લઈ અને બદલી શકતું નથી, તેથી ચલો "વિશ્વસનીય" છે): પ્રમાણપત્રનું નામ, નામ હોસ્ટ અને ડોમેન, પ્રમાણપત્રમાંથી એક્સ્ટેંશન.
• સર્વર તથ્યો સર્વર વિશેની માહિતી સાથે સંબંધિત ચલ-સંસ્કરણ, નામ, સર્વર IP સરનામું, પર્યાવરણ.
• એજન્ટ તથ્યો — ચલો સીધા પપેટ-એજન્ટ દ્વારા ઉમેરવામાં આવે છે, અને ફેક્ટર દ્વારા નહીં — પ્રમાણપત્રનું નામ, એજન્ટ સંસ્કરણ, પપેટ સંસ્કરણ.
• મુખ્ય ચલો - પેપેટમાસ્ટર ચલો (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.

સર્વર

Полноценную настройку паппетсервера и деплой на него кода в этой статье я не буду рассматривать, скажу лишь, что из коробки ставится вполне работоспособная версия сервера, не требующая дополнительной настройки для работы в условиях небольшого количества нод (скажем, до ста). Большее количество нод уже потребует тюнинга — по умолчанию puppetserver запускает не больше четырёх воркеров, для большей производительности нужно увеличить их число и не забыть увеличить лимиты памяти, иначе большую часть времени сервер будет garbage collect’ить.

કોડ ડિપ્લોયમેન્ટ - જો તમને તેની ઝડપથી અને સરળતાથી જરૂર હોય, તો પછી જુઓ (r10k પર)[https://github.com/puppetlabs/r10k], નાના સ્થાપનો માટે તે પૂરતું હોવું જોઈએ.

પરિશિષ્ટ 2: કોડિંગ માર્ગદર્શિકા

1. Выносите всю логику в классы и дефайны.
2. વર્ગો અને વ્યાખ્યાઓને મોડ્યુલમાં રાખો, નોડ્સનું વર્ણન કરતા મેનિફેસ્ટમાં નહીં.
3. તથ્યોનો ઉપયોગ કરો.
4. યજમાનનામો પર આધારિત ifs બનાવશો નહીં.
5. Не стесняйтесь добавлять параметры для классов и дефайнов — это лучше, чем неявная логика, спрятанная в теле класса/дефайна.

હું આગળના લેખમાં શા માટે આ કરવાની ભલામણ કરું છું તે હું સમજાવીશ.

નિષ્કર્ષ

ચાલો પરિચય સાથે સમાપ્ત કરીએ. હવે પછીના લેખમાં હું તમને Hiera, ENC અને PuppetDB વિશે જણાવીશ.

ફક્ત નોંધાયેલા વપરાશકર્તાઓ જ સર્વેમાં ભાગ લઈ શકે છે. સાઇન ઇન કરો, મહેરબાની કરીને.

હકીકતમાં, ત્યાં ઘણી વધુ સામગ્રી છે - હું નીચેના વિષયો પર લેખો લખી શકું છું, તમને જેના વિશે વાંચવામાં રસ હશે તેના પર મત આપો:

• 59,1%અદ્યતન કઠપૂતળીની રચનાઓ - કેટલાક આગલા-સ્તરના શિટ: લૂપ્સ, મેપિંગ અને અન્ય લેમ્બડા એક્સપ્રેશન્સ, રિસોર્સ કલેક્ટર્સ, નિકાસ કરેલા સંસાધનો અને પપેટ, ટૅગ્સ, પ્રદાતાઓ, અમૂર્ત ડેટા પ્રકારો દ્વારા આંતર-યજમાન સંચાર.13
• 31,8%"હું મારી માતાનો એડમિન છું" અથવા અમે કેવી રીતે અવિટોમાં વિવિધ સંસ્કરણોના ઘણા પોપેટ સર્વર્સ સાથે મિત્રો બનાવ્યા, અને સિદ્ધાંતમાં, પોપેટ સર્વરનું સંચાલન કરવા વિશેનો ભાગ.7
• 81,8%આપણે પપેટ કોડ કેવી રીતે લખીએ છીએ: ઇન્સ્ટ્રુમેન્ટેશન, ડોક્યુમેન્ટેશન, ટેસ્ટિંગ, CI/CD.18

22 વપરાશકર્તાઓએ મત ​​આપ્યો. 9 વપરાશકર્તાઓ દૂર રહ્યા.

સોર્સ: www.habr.com