ਕਠਪੁਤਲੀ ਇੱਕ ਸੰਰਚਨਾ ਪ੍ਰਬੰਧਨ ਸਿਸਟਮ ਹੈ। ਇਸਦੀ ਵਰਤੋਂ ਮੇਜ਼ਬਾਨਾਂ ਨੂੰ ਲੋੜੀਂਦੀ ਸਥਿਤੀ ਵਿੱਚ ਲਿਆਉਣ ਅਤੇ ਇਸ ਸਥਿਤੀ ਨੂੰ ਬਣਾਈ ਰੱਖਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

ਮੈਂ ਹੁਣ ਪੰਜ ਸਾਲਾਂ ਤੋਂ ਕਠਪੁਤਲੀ ਨਾਲ ਕੰਮ ਕਰ ਰਿਹਾ ਹਾਂ. ਇਹ ਟੈਕਸਟ ਲਾਜ਼ਮੀ ਤੌਰ 'ਤੇ ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼ਾਂ ਤੋਂ ਮੁੱਖ ਬਿੰਦੂਆਂ ਦਾ ਅਨੁਵਾਦਿਤ ਅਤੇ ਮੁੜ ਕ੍ਰਮਬੱਧ ਸੰਕਲਨ ਹੈ, ਜੋ ਸ਼ੁਰੂਆਤ ਕਰਨ ਵਾਲਿਆਂ ਨੂੰ ਕਠਪੁਤਲੀ ਦੇ ਤੱਤ ਨੂੰ ਜਲਦੀ ਸਮਝਣ ਦੀ ਆਗਿਆ ਦੇਵੇਗਾ।

ਮੁੱ .ਲੀ ਜਾਣਕਾਰੀ

ਕਠਪੁਤਲੀ ਦਾ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਕਲਾਇੰਟ-ਸਰਵਰ ਹੈ, ਹਾਲਾਂਕਿ ਇਹ ਸੀਮਤ ਕਾਰਜਸ਼ੀਲਤਾ ਦੇ ਨਾਲ ਸਰਵਰ ਰਹਿਤ ਸੰਚਾਲਨ ਦਾ ਸਮਰਥਨ ਵੀ ਕਰਦਾ ਹੈ।

ਓਪਰੇਸ਼ਨ ਦਾ ਇੱਕ ਪੁੱਲ ਮਾਡਲ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ: ਮੂਲ ਰੂਪ ਵਿੱਚ, ਹਰ ਅੱਧੇ ਘੰਟੇ ਵਿੱਚ ਇੱਕ ਵਾਰ, ਕਲਾਇੰਟ ਇੱਕ ਸੰਰਚਨਾ ਲਈ ਸਰਵਰ ਨਾਲ ਸੰਪਰਕ ਕਰਦੇ ਹਨ ਅਤੇ ਇਸਨੂੰ ਲਾਗੂ ਕਰਦੇ ਹਨ। ਜੇਕਰ ਤੁਸੀਂ Ansible ਨਾਲ ਕੰਮ ਕੀਤਾ ਹੈ, ਤਾਂ ਉਹ ਇੱਕ ਵੱਖਰੇ ਪੁਸ਼ ਮਾਡਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ: ਪ੍ਰਬੰਧਕ ਸੰਰਚਨਾ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਗਾਹਕ ਖੁਦ ਕੁਝ ਵੀ ਲਾਗੂ ਨਹੀਂ ਕਰਨਗੇ।

ਨੈੱਟਵਰਕ ਸੰਚਾਰ ਦੌਰਾਨ, ਦੋ-ਤਰੀਕੇ ਨਾਲ 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.

exec

ਬਾਹਰੀ ਕਮਾਂਡਾਂ ਚਲਾਉਂਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਮਾਪਦੰਡ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕਰਦੇ ਬਣਾਉਦਾ ਹੈ, ਸਿਰਫ਼ ਜੇਕਰ, ਜਦ ਤੱਕ ਜ ਤਾਜ਼ਗੀ ਨਾਲ, ਹਰ ਵਾਰ ਕਠਪੁਤਲੀ ਚਲਾਉਣ 'ਤੇ ਕਮਾਂਡ ਚਲਾਈ ਜਾਵੇਗੀ। ਸੂਚਨਾਵਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਦੇ ਯੋਗ - ਇੱਕ ਕਮਾਂਡ ਚਲਾਉਂਦਾ ਹੈ।

ਪੈਰਾਮੀਟਰ:

• ਸਰੋਤ ਦਾ ਨਾਮ - ਚਲਾਉਣ ਲਈ ਕਮਾਂਡ (ਵਿਕਲਪਿਕ)
• ਹੁਕਮ - ਚਲਾਉਣ ਲਈ ਕਮਾਂਡ (ਜੇ ਇਹ ਨਾਮ ਵਿੱਚ ਨਹੀਂ ਦਿੱਤਾ ਗਿਆ ਹੈ)
• ਮਾਰਗ — ਮਾਰਗ, ਜਿਸ ਵਿੱਚ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਫਾਇਲ ਦੀ ਖੋਜ ਕਰਨੀ ਹੈ
• ਸਿਰਫ਼ ਜੇਕਰ — ਜੇਕਰ ਇਸ ਪੈਰਾਮੀਟਰ ਵਿੱਚ ਦਿੱਤੀ ਕਮਾਂਡ ਜ਼ੀਰੋ ਰਿਟਰਨ ਕੋਡ ਨਾਲ ਪੂਰੀ ਹੋ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਮੁੱਖ ਕਮਾਂਡ ਨੂੰ ਚਲਾਇਆ ਜਾਵੇਗਾ।
• ਜਦ ਤੱਕ — ਜੇਕਰ ਇਸ ਪੈਰਾਮੀਟਰ ਵਿੱਚ ਦਿੱਤੀ ਕਮਾਂਡ ਗੈਰ-ਜ਼ੀਰੋ ਰਿਟਰਨ ਕੋਡ ਨਾਲ ਪੂਰੀ ਹੋ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਮੁੱਖ ਕਮਾਂਡ ਨੂੰ ਚਲਾਇਆ ਜਾਵੇਗਾ।
• ਬਣਾਉਦਾ ਹੈ — ਜੇਕਰ ਇਸ ਪੈਰਾਮੀਟਰ ਵਿੱਚ ਦਿੱਤੀ ਗਈ ਫਾਈਲ ਮੌਜੂਦ ਨਹੀਂ ਹੈ, ਤਾਂ ਮੁੱਖ ਕਮਾਂਡ ਨੂੰ ਚਲਾਇਆ ਜਾਵੇਗਾ
• ਤਾਜ਼ਗੀ ਨਾਲ - ਜੇ true, ਤਾਂ ਕਮਾਂਡ ਕੇਵਲ ਉਦੋਂ ਹੀ ਚਲਾਈ ਜਾਵੇਗੀ ਜਦੋਂ ਇਸ exec ਨੂੰ ਹੋਰ ਸਰੋਤਾਂ ਤੋਂ ਸੂਚਨਾ ਪ੍ਰਾਪਤ ਹੁੰਦੀ ਹੈ
• cwd — ਡਾਇਰੈਕਟਰੀ ਜਿਸ ਤੋਂ ਕਮਾਂਡ ਚਲਾਉਣੀ ਹੈ
• ਉਪਭੋਗੀ ਨੂੰ — ਯੂਜ਼ਰ ਜਿਸ ਤੋਂ ਕਮਾਂਡ ਚਲਾਉਣੀ ਹੈ
• ਦੇਣ ਵਾਲੇ - ਕਮਾਂਡ ਨੂੰ ਕਿਵੇਂ ਚਲਾਉਣਾ ਹੈ:
  • posix - ਇੱਕ ਬਾਲ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਿਰਫ਼ ਬਣਾਇਆ ਗਿਆ ਹੈ, ਨਿਸ਼ਚਿਤ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ ਮਾਰਗ
  • ਸ਼ੈੱਲ - ਕਮਾਂਡ ਸ਼ੈੱਲ ਵਿੱਚ ਲਾਂਚ ਕੀਤੀ ਗਈ ਹੈ /bin/sh, ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਮਾਰਗ, ਤੁਸੀਂ ਗਲੋਬਿੰਗ, ਪਾਈਪ ਅਤੇ ਹੋਰ ਸ਼ੈੱਲ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਆਮ ਤੌਰ 'ਤੇ ਆਪਣੇ ਆਪ ਖੋਜਿਆ ਜਾਂਦਾ ਹੈ ਜੇਕਰ ਕੋਈ ਵਿਸ਼ੇਸ਼ ਅੱਖਰ ਹਨ (|, ;, &&, || ਆਦਿ)।

ਕਰੋਨ

ਕ੍ਰੋਨਜੌਬਸ ਨੂੰ ਕੰਟਰੋਲ ਕਰਦਾ ਹੈ।

ਪੈਰਾਮੀਟਰ:

• ਸਰੋਤ ਦਾ ਨਾਮ - ਸਿਰਫ ਕੁਝ ਕਿਸਮ ਦਾ ਪਛਾਣਕਰਤਾ
• ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ - ਤਾਜ ਨੌਕਰੀ ਦੀ ਸਥਿਤੀ:
  • present - ਜੇ ਮੌਜੂਦ ਨਹੀਂ ਹੈ ਤਾਂ ਬਣਾਓ
  • absent - ਜੇਕਰ ਮੌਜੂਦ ਹੈ ਤਾਂ ਮਿਟਾਓ
• ਹੁਕਮ - ਕਿਹੜੀ ਕਮਾਂਡ ਚਲਾਉਣੀ ਹੈ
• ਵਾਤਾਵਰਣ ਨੂੰ — ਕਿਸ ਵਾਤਾਵਰਣ ਵਿੱਚ ਕਮਾਂਡ ਚਲਾਉਣੀ ਹੈ (ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲਾਂ ਦੀ ਸੂਚੀ ਅਤੇ ਉਹਨਾਂ ਦੇ ਮੁੱਲ ਦੁਆਰਾ =)
• ਉਪਭੋਗੀ ਨੂੰ — ਕਿਸ ਉਪਭੋਗਤਾ ਤੋਂ ਕਮਾਂਡ ਚਲਾਉਣੀ ਹੈ
• ਮਿੰਟ, ਘੰਟੇ, ਹਫਤੇ ਦਾ ਦਿਨ, ਮਹੀਨੇ, ਮਹੀਨੇ ਦਾ ਦਿਨ - ਕ੍ਰੋਨ ਨੂੰ ਕਦੋਂ ਚਲਾਉਣਾ ਹੈ। ਜੇਕਰ ਇਹਨਾਂ ਵਿੱਚੋਂ ਕੋਈ ਵੀ ਵਿਸ਼ੇਸ਼ਤਾ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤੀ ਗਈ ਹੈ, ਤਾਂ ਕ੍ਰੋਨਟੈਬ ਵਿੱਚ ਇਸਦਾ ਮੁੱਲ ਹੋਵੇਗਾ *.

ਕਠਪੁਤਲੀ 6.0 ਵਿੱਚ ਕਰੋਨ ਜਿਵੇਂ ਕਿ ਬਕਸੇ ਤੋਂ ਹਟਾ ਦਿੱਤਾ ਗਿਆ ਕਠਪੁਤਲੀ ਸਰਵਰ ਵਿੱਚ, ਇਸ ਲਈ ਆਮ ਸਾਈਟ 'ਤੇ ਕੋਈ ਦਸਤਾਵੇਜ਼ ਨਹੀਂ ਹਨ। ਪਰ ਉਹ ਬਕਸੇ ਵਿੱਚ ਹੈ ਕਠਪੁਤਲੀ-ਏਜੰਟ ਵਿੱਚ, ਇਸ ਲਈ ਇਸ ਨੂੰ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਸਥਾਪਤ ਕਰਨ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ। ਤੁਸੀਂ ਇਸਦੇ ਲਈ ਦਸਤਾਵੇਜ਼ ਦੇਖ ਸਕਦੇ ਹੋ ਕਠਪੁਤਲੀ ਦੇ ਪੰਜਵੇਂ ਸੰਸਕਰਣ ਲਈ ਦਸਤਾਵੇਜ਼ ਵਿੱਚ, ਜਾਂ GitHub 'ਤੇ.

ਆਮ ਤੌਰ 'ਤੇ ਸਰੋਤਾਂ ਬਾਰੇ

ਸਰੋਤ ਵਿਲੱਖਣਤਾ ਲਈ ਲੋੜ

ਸਭ ਤੋਂ ਆਮ ਗਲਤੀ ਜਿਸਦਾ ਅਸੀਂ ਸਾਹਮਣਾ ਕਰਦੇ ਹਾਂ ਡੁਪਲੀਕੇਟ ਘੋਸ਼ਣਾ. ਇਹ ਗਲਤੀ ਉਦੋਂ ਵਾਪਰਦੀ ਹੈ ਜਦੋਂ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਇੱਕੋ ਕਿਸਮ ਦੇ ਇੱਕੋ ਨਾਮ ਦੇ ਦੋ ਜਾਂ ਵੱਧ ਸਰੋਤ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ।

ਇਸ ਲਈ, ਮੈਂ ਦੁਬਾਰਾ ਲਿਖਾਂਗਾ: ਉਸੇ ਨੋਡ ਲਈ ਮੈਨੀਫੈਸਟ ਵਿੱਚ ਇੱਕੋ ਸਿਰਲੇਖ ਦੇ ਨਾਲ ਇੱਕੋ ਕਿਸਮ ਦੇ ਸਰੋਤ ਨਹੀਂ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ!

ਕਈ ਵਾਰ ਇੱਕੋ ਨਾਮ ਵਾਲੇ ਪੈਕੇਜ ਇੰਸਟਾਲ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਪਰ ਵੱਖ-ਵੱਖ ਪੈਕੇਜ ਪ੍ਰਬੰਧਕਾਂ ਨਾਲ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਤੁਹਾਨੂੰ ਪੈਰਾਮੀਟਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ 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,
) {
  ...
}

ਕਲਾਸਾਂ: ਕਲਾਸਨਾਮ ਬਨਾਮ ਕਲਾਸ{'ਕਲਾਸਨਾਮ':} ਸ਼ਾਮਲ ਕਰੋ

ਹਰ ਕਲਾਸ ਕਿਸਮ ਦਾ ਇੱਕ ਸਰੋਤ ਹੈ ਕਲਾਸ. ਜਿਵੇਂ ਕਿ ਕਿਸੇ ਹੋਰ ਕਿਸਮ ਦੇ ਸਰੋਤ ਦੇ ਨਾਲ, ਉਸੇ ਨੋਡ 'ਤੇ ਇੱਕੋ ਕਲਾਸ ਦੀਆਂ ਦੋ ਉਦਾਹਰਣਾਂ ਨਹੀਂ ਹੋ ਸਕਦੀਆਂ।

ਜੇਕਰ ਤੁਸੀਂ ਦੋ ਵਾਰ ਇੱਕੋ ਨੋਡ ਵਿੱਚ ਇੱਕ ਕਲਾਸ ਜੋੜਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹੋ class { 'classname':} (ਕੋਈ ਫਰਕ ਨਹੀਂ, ਵੱਖਰੇ ਜਾਂ ਇੱਕੋ ਜਿਹੇ ਪੈਰਾਮੀਟਰਾਂ ਨਾਲ), ਇੱਕ ਸੰਕਲਨ ਗਲਤੀ ਹੋਵੇਗੀ। ਪਰ ਜੇਕਰ ਤੁਸੀਂ ਸਰੋਤ ਸ਼ੈਲੀ ਵਿੱਚ ਇੱਕ ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਤੁਰੰਤ ਇਸਦੇ ਸਾਰੇ ਮਾਪਦੰਡਾਂ ਨੂੰ ਮੈਨੀਫੈਸਟ ਵਿੱਚ ਸਪਸ਼ਟ ਰੂਪ ਵਿੱਚ ਸੈੱਟ ਕਰ ਸਕਦੇ ਹੋ।

ਹਾਲਾਂਕਿ, ਜੇਕਰ ਤੁਸੀਂ ਵਰਤਦੇ ਹੋ include, ਫਿਰ ਕਲਾਸ ਨੂੰ ਜਿੰਨੀ ਵਾਰ ਚਾਹੋ ਜੋੜਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਤੱਥ ਇਹ ਹੈ ਕਿ include ਇੱਕ idempotent ਫੰਕਸ਼ਨ ਹੈ ਜੋ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਇੱਕ ਕਲਾਸ ਸ਼ਾਮਲ ਕੀਤੀ ਗਈ ਹੈ। ਜੇਕਰ ਕਲਾਸ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਨਹੀਂ ਹੈ, ਤਾਂ ਇਹ ਇਸਨੂੰ ਜੋੜਦਾ ਹੈ, ਅਤੇ ਜੇਕਰ ਇਹ ਪਹਿਲਾਂ ਹੀ ਮੌਜੂਦ ਹੈ, ਤਾਂ ਇਹ ਕੁਝ ਨਹੀਂ ਕਰਦਾ। ਪਰ ਵਰਤਣ ਦੇ ਮਾਮਲੇ ਵਿੱਚ include ਤੁਸੀਂ ਕਲਾਸ ਘੋਸ਼ਣਾ ਦੇ ਦੌਰਾਨ ਕਲਾਸ ਪੈਰਾਮੀਟਰ ਸੈੱਟ ਨਹੀਂ ਕਰ ਸਕਦੇ ਹੋ - ਸਾਰੇ ਲੋੜੀਂਦੇ ਮਾਪਦੰਡ ਇੱਕ ਬਾਹਰੀ ਡਾਟਾ ਸਰੋਤ - Hiera ਜਾਂ ENC ਵਿੱਚ ਸੈੱਟ ਕੀਤੇ ਜਾਣੇ ਚਾਹੀਦੇ ਹਨ। ਅਸੀਂ ਅਗਲੇ ਲੇਖ ਵਿਚ ਉਨ੍ਹਾਂ ਬਾਰੇ ਗੱਲ ਕਰਾਂਗੇ।

ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ

ਜਿਵੇਂ ਕਿ ਪਿਛਲੇ ਬਲਾਕ ਵਿੱਚ ਕਿਹਾ ਗਿਆ ਸੀ, ਇੱਕੋ ਕਲਾਸ ਇੱਕ ਨੋਡ 'ਤੇ ਇੱਕ ਤੋਂ ਵੱਧ ਵਾਰ ਮੌਜੂਦ ਨਹੀਂ ਹੋ ਸਕਦੀ ਹੈ। ਹਾਲਾਂਕਿ, ਕੁਝ ਮਾਮਲਿਆਂ ਵਿੱਚ ਤੁਹਾਨੂੰ ਇੱਕੋ ਨੋਡ 'ਤੇ ਵੱਖ-ਵੱਖ ਪੈਰਾਮੀਟਰਾਂ ਦੇ ਨਾਲ ਕੋਡ ਦੇ ਇੱਕੋ ਬਲਾਕ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿਚ, ਇਸਦੀ ਆਪਣੀ ਕਿਸਮ ਦੇ ਸਰੋਤ ਦੀ ਜ਼ਰੂਰਤ ਹੈ.

ਉਦਾਹਰਨ ਲਈ, PHP ਮੋਡੀਊਲ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ, ਅਸੀਂ ਅਵੀਟੋ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਕੰਮ ਕਰਦੇ ਹਾਂ:

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 ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਇੱਕ ਮੋਡੀਊਲ ਹੋ ਸਕਦਾ ਹੈ, ਆਦਿ।

ਮੋਡੀਊਲ ਵਰਜਨ ਕੀਤੇ ਗਏ ਹਨ, ਅਤੇ ਇੱਕ ਦੂਜੇ 'ਤੇ ਮੋਡੀਊਲ ਦੀ ਨਿਰਭਰਤਾ ਵੀ ਸਮਰਥਿਤ ਹੈ। ਮੋਡੀਊਲ ਦਾ ਇੱਕ ਖੁੱਲਾ ਭੰਡਾਰ ਹੈ - ਕਠਪੁਤਲੀ ਫੋਰਜ.

ਕਠਪੁਤਲੀ ਸਰਵਰ 'ਤੇ, ਮੋਡੀਊਲ ਰੂਟ ਡਾਇਰੈਕਟਰੀ ਦੇ ਮੋਡੀਊਲ ਸਬ-ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਸਥਿਤ ਹਨ। ਹਰੇਕ ਮੋਡੀਊਲ ਦੇ ਅੰਦਰ ਇੱਕ ਮਿਆਰੀ ਡਾਇਰੈਕਟਰੀ ਸਕੀਮ ਹੁੰਦੀ ਹੈ - ਮੈਨੀਫੈਸਟ, ਫਾਈਲਾਂ, ਟੈਂਪਲੇਟਸ, lib, ਅਤੇ ਹੋਰ।

ਇੱਕ ਮੋਡੀਊਲ ਵਿੱਚ ਫਾਈਲ ਬਣਤਰ

ਮੋਡੀਊਲ ਦੇ ਰੂਟ ਵਿੱਚ ਵਰਣਨਯੋਗ ਨਾਵਾਂ ਨਾਲ ਹੇਠ ਲਿਖੀਆਂ ਡਾਇਰੈਕਟਰੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ:

• 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 ਜਾਂ key=value ਫਾਰਮੈਟ ਵਿੱਚ ਮਿਆਰੀ ਆਉਟਪੁੱਟ ਲਈ ਜਾਣਕਾਰੀ ਆਉਟਪੁੱਟ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ।

ਇਹ ਨਾ ਭੁੱਲੋ ਕਿ ਤੱਥ ਉਹਨਾਂ ਸਾਰੇ ਨੋਡਾਂ 'ਤੇ ਲਾਗੂ ਹੁੰਦੇ ਹਨ ਜੋ ਪੌਪਪੇਟ ਸਰਵਰ ਦੁਆਰਾ ਨਿਯੰਤਰਿਤ ਹੁੰਦੇ ਹਨ ਜਿਸ 'ਤੇ ਤੁਹਾਡਾ ਮੋਡੀਊਲ ਤਾਇਨਾਤ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਸ ਲਈ, ਸਕ੍ਰਿਪਟ ਵਿੱਚ, ਇਹ ਜਾਂਚ ਕਰਨ ਦਾ ਧਿਆਨ ਰੱਖੋ ਕਿ ਸਿਸਟਮ ਵਿੱਚ ਤੁਹਾਡੇ ਤੱਥ ਦੇ ਕੰਮ ਕਰਨ ਲਈ ਜ਼ਰੂਰੀ ਸਾਰੇ ਪ੍ਰੋਗਰਾਮ ਅਤੇ ਫਾਈਲਾਂ ਹਨ।

#!/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 ਪਤਾ, ਵਾਤਾਵਰਣ।
• ਏਜੰਟ ਤੱਥ — ਵੇਰੀਏਬਲ ਸਿੱਧੇ ਕਠਪੁਤਲੀ-ਏਜੰਟ ਦੁਆਰਾ ਸ਼ਾਮਲ ਕੀਤੇ ਗਏ ਹਨ, ਨਾ ਕਿ ਫੈਕਟਰ ਦੁਆਰਾ — ਸਰਟੀਫਿਕੇਟ ਦਾ ਨਾਮ, ਏਜੰਟ ਸੰਸਕਰਣ, ਕਠਪੁਤਲੀ ਸੰਸਕਰਣ।
• ਮਾਸਟਰ ਵੇਰੀਏਬਲ - ਪੈਪੇਟਮਾਸਟਰ ਵੇਰੀਏਬਲ (sic!) ਇਹ ਲਗਭਗ ਉਸੇ ਤਰ੍ਹਾਂ ਹੈ ਜਿਵੇਂ ਕਿ ਵਿੱਚ ਸਰਵਰ ਤੱਥ, ਪਲੱਸ ਸੰਰਚਨਾ ਪੈਰਾਮੀਟਰ ਮੁੱਲ ਉਪਲਬਧ ਹਨ।
• ਕੰਪਾਈਲਰ ਵੇਰੀਏਬਲ — ਕੰਪਾਈਲਰ ਵੇਰੀਏਬਲ ਜੋ ਹਰੇਕ ਸਕੋਪ ਵਿੱਚ ਵੱਖਰੇ ਹੁੰਦੇ ਹਨ: ਮੌਜੂਦਾ ਮੋਡੀਊਲ ਦਾ ਨਾਮ ਅਤੇ ਮੋਡੀਊਲ ਦਾ ਨਾਮ ਜਿਸ ਵਿੱਚ ਮੌਜੂਦਾ ਵਸਤੂ ਨੂੰ ਐਕਸੈਸ ਕੀਤਾ ਗਿਆ ਸੀ। ਉਹਨਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਉਦਾਹਰਨ ਲਈ, ਇਹ ਜਾਂਚ ਕਰਨ ਲਈ ਕਿ ਤੁਹਾਡੀਆਂ ਪ੍ਰਾਈਵੇਟ ਕਲਾਸਾਂ ਦੂਜੇ ਮੋਡਿਊਲਾਂ ਤੋਂ ਸਿੱਧੇ ਨਹੀਂ ਵਰਤੀਆਂ ਜਾ ਰਹੀਆਂ ਹਨ।

ਜੋੜ 1: ਇਸ ਸਭ ਨੂੰ ਕਿਵੇਂ ਚਲਾਉਣਾ ਅਤੇ ਡੀਬੱਗ ਕਰਨਾ ਹੈ?

ਲੇਖ ਵਿੱਚ ਕਠਪੁਤਲੀ ਕੋਡ ਦੀਆਂ ਬਹੁਤ ਸਾਰੀਆਂ ਉਦਾਹਰਣਾਂ ਸਨ, ਪਰ ਸਾਨੂੰ ਇਹ ਨਹੀਂ ਦੱਸਿਆ ਕਿ ਇਸ ਕੋਡ ਨੂੰ ਕਿਵੇਂ ਚਲਾਉਣਾ ਹੈ। ਖੈਰ, ਮੈਂ ਆਪਣੇ ਆਪ ਨੂੰ ਠੀਕ ਕਰ ਰਿਹਾ ਹਾਂ।

ਕਠਪੁਤਲੀ ਨੂੰ ਚਲਾਉਣ ਲਈ ਇੱਕ ਏਜੰਟ ਕਾਫ਼ੀ ਹੈ, ਪਰ ਜ਼ਿਆਦਾਤਰ ਮਾਮਲਿਆਂ ਲਈ ਤੁਹਾਨੂੰ ਇੱਕ ਸਰਵਰ ਦੀ ਵੀ ਲੋੜ ਪਵੇਗੀ।

ਏਜੰਟ

ਘੱਟੋ-ਘੱਟ ਸੰਸਕਰਣ XNUMX ਤੋਂ, ਕਠਪੁਤਲੀ-ਏਜੰਟ ਪੈਕੇਜਾਂ ਤੋਂ ਅਧਿਕਾਰਤ Puppetlabs ਰਿਪੋਜ਼ਟਰੀ ਸਾਰੀਆਂ ਨਿਰਭਰਤਾਵਾਂ (ਰੂਬੀ ਅਤੇ ਸੰਬੰਧਿਤ ਰਤਨ) ਸ਼ਾਮਲ ਹਨ, ਇਸਲਈ ਕੋਈ ਇੰਸਟਾਲੇਸ਼ਨ ਮੁਸ਼ਕਲਾਂ ਨਹੀਂ ਹਨ (ਮੈਂ ਡੇਬੀਅਨ-ਅਧਾਰਿਤ ਵੰਡਾਂ ਬਾਰੇ ਗੱਲ ਕਰ ਰਿਹਾ ਹਾਂ - ਅਸੀਂ 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: ਕੋਡਿੰਗ ਦਿਸ਼ਾ-ਨਿਰਦੇਸ਼

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