ProHoster > Blog > Administratioun > Aféierung an Puppet

Aféierung an Puppet

Puppet ass e Konfiguratiounsmanagementsystem. Et gëtt benotzt fir Hosten an de gewënschten Zoustand ze bréngen an dësen Zoustand z'erhalen.

Ech schaffe mat Puppet fir iwwer fënnef Joer elo. Dësen Text ass am Wesentlechen eng iwwersat an nei bestallt Kompilatioun vu Schlësselpunkten aus der offizieller Dokumentatioun, déi Ufänger erlaabt séier d'Essenz vu Puppet ze verstoen.

Aféierung an Puppet

Basis Informatioun

De Puppet Betribssystem ass Client-Server, obwuel et och Serverlos Operatioun mat limitéierter Funktionalitéit ënnerstëtzt.

A Pull Modell vun Operatioun benotzt: Par défaut, eemol all hallef Stonn, Clienten Kontakt de Server fir eng Configuratioun an gëllen. Wann Dir mat Ansible geschafft hutt, da benotze se en anere Push-Modell: den Administrateur initiéiert de Prozess fir d'Konfiguratioun z'applizéieren, d'Clientë selwer wäerten näischt applizéieren.

Wärend der Netzwierkkommunikatioun gëtt zwee-Wee TLS Verschlësselung benotzt: de Server an de Client hunn hir eege privat Schlësselen an entspriechend Certificaten. Normalerweis gëtt de Server Certificaten fir Clienten eraus, awer am Prinzip ass et méiglech en externen CA ze benotzen.

Aféierung fir Manifestatiounen

An Puppet Terminologie op de Poppenserver verbannen Noden (Knäppchen). D'Konfiguratioun fir d'Node gëtt geschriwwe an Manifestatiounen an enger spezieller Programméiersprooch - Puppet DSL.

Puppet DSL ass eng deklarativ Sprooch. Et beschreift de gewënschten Zoustand vum Node a Form vun Deklaratioune vun eenzelne Ressourcen, zum Beispill:

  • De Fichier existéiert an et huet spezifeschen Inhalt.
  • De Package ass installéiert.
  • De Service huet ugefaang.

Ressourcen kënne matenee verbonne sinn:

  • Et gi Ofhängegkeeten, si beaflossen d'Uerdnung an där d'Ressourcen benotzt ginn.
    Zum Beispill, "installéiere fir d'éischt de Package, ännert dann d'Konfiguratiounsdatei, start dann de Service."
  • Et ginn Notifikatiounen - wann eng Ressource geännert huet, schéckt se Notifikatiounen un d'Ressourcen, déi se abonnéiert hunn.
    Zum Beispill, wann d'Konfiguratiounsdatei ännert, kënnt Dir de Service automatesch nei starten.

Zousätzlech huet d'Puppet DSL Funktiounen a Variabelen, souwéi bedingend Aussoen a Selektor. Verschidde Template Mechanismen ginn och ënnerstëtzt - EPP an ERB.

Puppet ass am Ruby geschriwwen, sou datt vill vun de Konstruktiounen a Begrëffer vun do geholl ginn. Ruby erlaabt Iech Puppet auszebauen - komplex Logik derbäi, nei Aarte vu Ressourcen, Funktiounen.

Wärend Puppet leeft, Manifestatiounen fir all spezifesch Node um Server ginn an e Verzeichnis kompiléiert. directory ass eng Lëscht vu Ressourcen an hir Relatiounen no der Berechnung vum Wäert vu Funktiounen, Variabelen an Expansioun vun bedingte Aussoen.

Syntax a Codestyle

Hei sinn Sektiounen vun der offizieller Dokumentatioun déi Iech hëllefen d'Syntax ze verstoen wann d'Beispiller net genuch sinn:

Hei ass e Beispill vu wéi de Manifest ausgesäit:

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

Indentatioun an Zeilbrems sinn net en erfuerderlechen Deel vum Manifest, awer et gëtt e recommandéiert Stil Guide. Resumé:

  • Zwee-Raum indents, Tabs ginn net benotzt.
  • Curly Klamere sinn duerch e Raum getrennt ginn net vun engem Raum getrennt;
  • Kommen no all Parameter, dorënner de leschten. All Parameter ass op enger separater Linn. Eng Ausnam gëtt gemaach fir de Fall ouni Parameteren an ee Parameter: Dir kënnt op enger Zeil an ouni Komma schreiwen (d.h. resource { 'title': } и resource { 'title': param => value }).
  • D'Pfeiler op de Parameteren sollen um selwechten Niveau sinn.
  • Ressource Relatioun Pfeile sinn virun hinnen geschriwwen.

Plaz vun Fichieren op Pappetserver

Fir weider Erklärung wäert ech d'Konzept vum "root directory" virstellen. De Root Verzeechnes ass de Verzeechnes deen d'Puppet Konfiguratioun fir e spezifesche Node enthält.

De Root Verzeechnes variéiert jee no der Versioun vu Puppet an den Ëmfeld benotzt. Ëmfeld sinn onofhängeg Sätz vun der Konfiguratioun déi an getrennten Verzeichnisser gespäichert sinn. Normalerweis a Kombinatioun mat Git benotzt, an deem Fall Ëmfeld aus Git Branchen erstallt ginn. Deementspriechend ass all Node an engem oder aneren Ëmfeld lokaliséiert. Dëst kann am Node selwer konfiguréiert ginn, oder an ENC, iwwer déi ech am nächsten Artikel schwätzen.

  • An der drëtter Versioun ("al Puppet") war de Basisverzeechnes /etc/puppet. D'Benotzung vun Ëmfeld ass fakultativ - zum Beispill, mir benotzen se net mat der aler Puppet. Wann Ëmfeld benotzt ginn, gi se normalerweis gespäichert /etc/puppet/environments, wäert de Root Verzeichnis den Ëmfeldsverzeechnes sinn. Wann Ëmfeld net benotzt ginn, gëtt de Root Verzeichnis de Basisverzeechnes.
  • Vun der véierter Versioun un ("nei Puppet") gouf d'Benotzung vun Ëmfeld obligatoresch, an de Basisverzeechnes gouf op /etc/puppetlabs/code. Deementspriechend ginn Ëmfeld an gespäichert /etc/puppetlabs/code/environments, Root Verzeechnes ass den Ëmfeld Verzeechnes.

Et muss en Ënnerverzeechnes am Root-Verzeichnis sinn manifests, déi een oder méi Manifestatiounen enthält, déi d'Noden beschreiwen. Zousätzlech sollt et en Ënnerverzeechnes sinn modules, déi d'Module enthält. Ech soen Iech wat Moduler e bësse méi spéit sinn. Zousätzlech kann déi al Puppet och e Subdirectory hunn files, déi verschidde Dateien enthält, déi mir op d'Knäppchen kopéieren. An der neier Puppet sinn all Dateien a Moduler plazéiert.

Manifestdateien hunn d'Extensioun .pp.

E puer Kampf Beispiller

Beschreiwung vum Node a Ressource op et

Op der Node server1.testdomain eng Datei muss erstallt ginn /etc/issue mat Inhalt Debian GNU/Linux n l. De Fichier muss vun engem Benotzer a Grupp gehéiert ginn root, Zougangsrechter musse sinn 644.

Mir schreiwen e Manifest:

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 в начале будет воспринято как записанное в восьмеричной системе, и всё пойдёт не так, как задумано
    }
}

Relatiounen tëscht Ressourcen op engem Node

Op der Node server2.testdomain nginx muss lafen, schafft mat enger virdru preparéierter Konfiguratioun.

Loosst eis de Problem zerstéieren:

  • De Package muss installéiert ginn nginx.
  • Et ass néideg datt d'Konfiguratiounsdateien vum Server kopéiert ginn.
  • De Service muss lafen nginx.
  • Wann d'Konfiguratioun aktualiséiert gëtt, muss de Service nei gestart ginn.

Mir schreiwen e Manifest:

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 получает уведомление,
  # соответствующий сервис перезапускается.
}

Fir dëst ze funktionéieren, braucht Dir ongeféier déi folgend Dateiplaz um Marionettenserver:

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

Ressource Zorte

Eng komplett Lëscht vun ënnerstëtzt Ressource Zorte kann hei fonnt ginn an der Dokumentatioun, Hei wäert ech fënnef Basistypen beschreiwen, déi a menger Praxis genuch sinn fir déi meescht Problemer ze léisen.

Fichier

Managt Dateien, Verzeichnisser, Symlinks, hiren Inhalt an Zougangsrechter.

Parameteren:

  • Ressource Numm - Wee op d'Datei (optional)
  • Wee - Wee fir d'Datei (wann et net am Numm uginn ass)
  • garantéieren - Dateityp:
    • absent - läschen eng Datei
    • present - et muss e Fichier vun all Typ sinn (wann et keng Datei gëtt, gëtt eng regulär Datei erstallt)
    • file - regelméisseg Fichier
    • directory - Verzeechnes
    • link - symbolesch
  • Inhalt - Dateiinhalt (gëeegent nëmme fir normal Dateien, kann net zesumme benotzt ginn Quell oder Zil gesat)
  • Quell - e Link op de Wee aus deem Dir den Inhalt vun der Datei kopéiere wëllt (kann net zesumme mat Inhalt oder Zil gesat). Kann entweder als URI mat engem Schema spezifizéiert ginn puppet: (dann Fichier'en aus dem Puppis Server benotzt ginn), a mat der Schema http: (Ech hoffen et kloer ass wat an dësem Fall geschéie wäert), an och mat der Diagramm file: oder als absolute Wee ouni Schema (da gëtt d'Datei vum lokalen FS um Node benotzt)
  • Zil gesat - wou de Symlink soll weisen (kann net zesumme mat Inhalt oder Quell)
  • Besëtzer - de Benotzer deen d'Datei besëtze soll
  • Grupp - d'Grupp zu där de Fichier gehéiere soll
  • Modus - Datei Permissiounen (als String)
  • Réckwee - erméiglecht rekursiv Verzeechnesveraarbechtung
  • ze räissen - erlaabt Dateien ze läschen déi net an Puppet beschriwwe sinn
  • Kraaft - erméiglecht d'Verzeechnes ze läschen déi net an der Puppet beschriwwe sinn

Pak

Installéiert a läscht Packagen. Fähëg Notifikatiounen ze handhaben - installéiert de Package nei wann de Parameter spezifizéiert ass reinstall_on_refresh.

Parameteren:

  • Ressource Numm - Package Numm (optional)
  • Numm - Package Numm (wann net am Numm uginn)
  • Fournisseur - Package Manager ze benotzen
  • garantéieren - gewënschten Zoustand vum Package:
    • present, installed - all Versioun installéiert
    • latest - lescht Versioun installéiert
    • absent - geläscht (apt-get remove)
    • purged - geläscht zesumme mat Konfiguratiounsdateien (apt-get purge)
    • held - Package Versioun ass gespaart (apt-mark hold)
    • любая другая строка - déi spezifizéiert Versioun ass installéiert
  • reinstall_on_refresh -wann true, dann beim Empfang vun der Notifikatioun gëtt de Package nei installéiert. Nëtzlech fir Quell-baséiert Verdeelungen, wou d'Rekonstruktioun vun Packagen néideg ka sinn wann d'Buildparameter geännert ginn. Default false.

Service

Geréiert Servicer. Fähëg Notifikatiounen ze veraarbechten - de Service nei starten.

Parameteren:

  • Ressource Numm - Service ze verwalten (optional)
  • Numm - de Service dee geréiert muss ginn (wann net am Numm uginn)
  • garantéieren - gewënschten Zoustand vum Service:
    • running - lancéiert
    • stopped - gestoppt
  • aktivéiert - kontrolléiert d'Fäegkeet fir de Service unzefänken:
    • true - Autorun ass aktivéiert (systemctl enable)
    • mask - verkleed (systemctl mask)
    • false - Autorun ass ausgeschalt (systemctl disable)
  • Neistart - Kommando fir de Service nei ze starten
  • Status - Kommando fir de Servicestatus z'iwwerpréiwen
  • huet nei starten - uginn ob de Service Initscript den Neistart ënnerstëtzt. Wann false an de Parameter gëtt uginn Neistart - de Wäert vun dësem Parameter gëtt benotzt. Wann false an Parameter Neistart net spezifizéiert - de Service gëtt gestoppt a fänkt un nei ze starten (awer systemd benotzt de Kommando systemctl restart).
  • hasstatus - uginn ob de Service Initscript de Kommando ënnerstëtzt status. Wann false, da gëtt de Parameterwäert benotzt Status. Default true.

exec

Leeft extern Kommandoen. Wann Dir keng Parameteren uginn entsteet, nëmmen wann, ausser oder erfrëschend, de Kommando gëtt all Kéier wann Puppet lafen. Kënnen Notifikatiounen veraarbecht - leeft e Kommando.

Parameteren:

  • Ressource Numm - Kommando auszeféieren (optional)
  • Kommando - de Kommando auszeféieren (wann et net am Numm spezifizéiert ass)
  • Wee - Weeër fir no der ausführbarer Datei ze sichen
  • nëmmen wann - wann de Kommando an dësem Parameter spezifizéiert mat engem Null Retour Code ofgeschloss ass, gëtt den Haaptbefehl ausgefouert
  • ausser - wann de Kommando an dësem Parameter spezifizéiert mat engem Net-Null Retour Code ofgeschloss ass, gëtt den Haaptbefehl ausgefouert
  • entsteet - wann d'Datei an dësem Parameter spezifizéiert net existéiert, gëtt den Haaptbefehl ausgefouert
  • erfrëschend -wann true, da gëtt de Kommando nëmmen ausgefouert wann dës Exekutioun Notifikatioun vun anere Ressourcen kritt
  • cwd - Verzeechnes aus deem de Kommando ausféiert
  • Benotzersäit - de Benotzer vun deem de Kommando ausféiert
  • Fournisseur - wéi Dir de Kommando ausféiert:
    • posix - e Kand Prozess ass einfach erstallt, gitt sécher ze spezifizéieren Wee
    • Réibau - de Kommando gëtt an der Shell gestart /bin/sh, kann net spezifizéiert ginn Wee, Dir kënnt Globbing, Päifen an aner Shell Feature benotzen. Normalerweis automatesch festgestallt wann et speziell Zeechen (|, ;, &&, || a sou weider).

cron

Kontrollen cronjobs.

Parameteren:

  • Ressource Numm - just eng Zort Identifizéierer
  • garantéieren - Krounjob Staat:
    • present - schafen wann net existéieren
    • absent - läschen wann existéiert
  • Kommando - wat Kommando ze lafen
  • Emwelt - a wéi engem Ëmfeld fir de Kommando auszeféieren (Lëscht vun Ëmfeldvariablen an hir Wäerter iwwer =)
  • Benotzersäit - vu wéi engem Benotzer de Kommando ausféiert
  • Minutt, Stonn, Wochendag, Mount, Mountdag - wann Cron lafen. Wann eng vun dësen Attributer net spezifizéiert ass, gëtt säi Wäert an der Crontab *.

An Puppet 6.0 cron wéi wann aus der Këscht geläscht am Puppetserver, also gëtt et keng Dokumentatioun um allgemenge Site. Awer hien ass an der Këscht am Puppet-Agent, also ass et net néideg et separat z'installéieren. Dir kënnt d'Dokumentatioun dofir gesinn an der Dokumentatioun fir déi fënneft Versioun vu Puppet, oder op GitHub.

Iwwer Ressourcen am Allgemengen

Ufuerderunge fir Ressource Eenzegaartegkeet

De stäerkste gemeinsam Feeler mir begéinen ass Duplikat Deklaratioun. Dëse Feeler geschitt wann zwee oder méi Ressourcen vum selwechten Typ mam selwechten Numm am Verzeechnes erscheinen.

Dofir schreiwen ech nach eng Kéier: Manifestatiounen fir deeselwechten Node solle keng Ressourcen vum selwechten Typ mam selwechten Titel enthalen!

Heiansdo ass et néideg Pakete mam selwechten Numm z'installéieren, awer mat verschiddene Packagemanager. An dësem Fall musst Dir de Parameter benotzen namefir de Feeler ze vermeiden:

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

Aner Ressourcentypen hunn ähnlech Optiounen fir Duplikatioun ze vermeiden - name у Service, command у exec, a sou weider.

Metaparameter

All Ressource Typ huet e puer speziell Parameteren, onofhängeg vun hirer Natur.

Voll Lëscht vun Meta Parameteren an der Puppet Dokumentatioun.

Kuerz Lëscht:

  • verlaangen - Dëse Parameter weist op wéi eng Ressourcen dës Ressource hänkt.
  • virum - Dëse Parameter spezifizéiert wéi eng Ressourcen vun dëser Ressource ofhängeg sinn.
  • abonnéieren - Dëse Parameter spezifizéiert aus wéi enge Ressourcen dës Ressource Notifikatiounen kritt.
  • notize - Dëse Parameter spezifizéiert wéi eng Ressourcen Notifikatioune vun dëser Ressource kréien.

All déi opgezielt Metaparameter akzeptéieren entweder eng eenzeg Ressource Link oder eng Rei vu Linken an eckeg Klammern.

Linken op Ressourcen

E Ressourcelink ass einfach eng Ernimmung vun der Ressource. Si ginn haaptsächlech benotzt fir Ofhängegkeeten ze weisen. Referenz op eng net existent Ressource verursaacht e Kompiléierungsfehler.

D'Syntax vum Link ass wéi follegt: Ressourcentyp mat engem grousse Buschtaf (wann den Typnumm duebel Colonen enthält, da gëtt all Deel vum Numm tëscht de Colonen mat Kapital gesat), dann de Ressourcenumm a véiereckege Klammeren (de Fall vum Numm) ännert sech net!). Et soll keng Plazen sinn véiereckege Klammeren sinn schrëftlech direkt nom Typ Numm.

Beispill:

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

Ofhängegkeeten an Notifikatiounen

Dokumentatioun hei.

Wéi virdru scho gesot, einfach Ofhängegkeeten tëscht Ressourcen sinn transitiv. Iwwregens, passt virsiichteg wann Dir Ofhängegkeete bäidréit - Dir kënnt zyklesch Ofhängegkeeten erstellen, wat e Kompiléierungsfehler verursaacht.

Am Géigesaz zu Ofhängegkeeten sinn Notifikatiounen net transitiv. Déi folgend Regele gëlle fir Notifikatiounen:

  • Wann d'Ressource eng Notifikatioun kritt, gëtt se aktualiséiert. D'Aktualiséierungsaktiounen hänke vum Ressourcetyp of - exec leeft de Kommando aus, Service Restart de Service, Pak reinstalléiert de Package. Wann d'Ressource keng Aktualiséierungsaktioun definéiert huet, da geschitt näischt.
  • Wärend engem Laf vu Puppet gëtt d'Ressource net méi wéi eemol aktualiséiert. Dëst ass méiglech well Notifikatiounen Ofhängegkeeten enthalen an d'Ofhängegkeetsgrafik keng Zyklen enthält.
  • Wann Puppet den Zoustand vun enger Ressource ännert, schéckt d'Ressource Notifikatiounen un all Ressourcen, déi se abonnéiert hunn.
  • Wann eng Ressource aktualiséiert gëtt, schéckt se Notifikatiounen un all Ressourcen, déi op se abonnéiert sinn.

Ëmgank mat onspezifizéierten Parameteren

Als Regel, wann e puer Ressource Parameter net eng Default Wäert hunn an dësem Parameter ass net am Manifest uginn, da wäert Puppis dëser Propriétéit fir déi entspriechend Ressource op der Node net änneren. Zum Beispill, wann eng Ressource vun Typ Fichier Parameter net uginn owner, da wäert Puppet de Besëtzer vun der entspriechender Datei net änneren.

Aféierung fir Klassen, Verännerlechen an Definitiounen

Ugeholl mir hunn e puer Noden déi deeselwechten Deel vun der Konfiguratioun hunn, awer et ginn och Differenzen - soss kéinte mir et alles an engem Block beschreiwen node {}. Natierlech kënnt Dir einfach identesch Deeler vun der Konfiguratioun kopéieren, awer allgemeng ass dëst eng schlecht Léisung - d'Konfiguratioun wiisst, a wann Dir den allgemengen Deel vun der Konfiguratioun ännert, musst Dir datselwecht op ville Plazen änneren. Zur selwechter Zäit ass et einfach e Feeler ze maachen, an allgemeng ass de DRY (net widderhuelen) Prinzip aus engem Grond erfonnt.

Fir dëse Problem ze léisen gëtt et esou en Design wéi класс.

Klassen

Klass ass e genannte Block vum Poppet Code. Klassen sinn néideg fir de Code ze benotzen.

Als éischt muss d'Klass beschriwwe ginn. D'Beschreiwung selwer füügt keng Ressourcen iwwerall dobäi. D'Klass ass a Manifestatiounen beschriwwen:

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

Duerno kann d'Klass benotzt ginn:

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

E Beispill vun der viregter Aufgab - loosst eis d'Installatioun an d'Konfiguratioun vun nginx an eng Klass réckelen:

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
}

Verännerlechen

D'Klass aus dem virege Beispill ass guer net flexibel well se ëmmer déiselwecht nginx Konfiguratioun bréngt. Loosst eis de Wee op d'Konfiguratiounsvariabel maachen, da kann dës Klass benotzt ginn fir nginx mat all Konfiguratioun z'installéieren.

Et kann gemaach ginn benotzt Verännerlechen.

Opgepasst: Variablen am Puppet sinn onverännerbar!

Zousätzlech kann eng Variabel nëmmen zougänglech sinn nodeems se deklaréiert gouf, soss gëtt de Wäert vun der Variabel undef.

Beispill fir mat Variabelen ze schaffen:

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

Puppet huet Nummraim, an d'Verännerlechen, deementspriechend, hunn Beräich vun der Visibilitéit: Eng Variabel mam selwechten Numm kann a verschiddene Nummraim definéiert ginn. Wann Dir de Wäert vun enger Variabel léist, gëtt d'Variabel am aktuellen Nummraum gesicht, dann am uschléissenden Nummraum, a sou weider.

Namespace Beispiller:

  • global - Verännerlechen ausserhalb der Klass oder Node Beschreiwung ginn do;
  • Node Nummraum an der Node Beschreiwung;
  • Klass Nummraum an der Klass Beschreiwung.

Fir Ambiguititéit ze vermeiden beim Zougang zu enger Variabel, kënnt Dir den Nummraum am Variabelnumm uginn:

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

Loosst eis d'accord sinn datt de Wee zu der nginx Konfiguratioun an der Variabel läit $nginx_conf_source. Da gesäit d'Klass esou aus:

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
}

Wéi och ëmmer, dat gegebene Beispill ass schlecht well et e "geheimt Wëssen" gëtt datt iergendwou an der Klass eng Variabel mat esou an esou engem Numm benotzt gëtt. Et ass vill méi korrekt dëst Wëssen allgemeng ze maachen - Klassen kënnen Parameteren hunn.

Klass Parameteren si Variabelen am Klassennummraum, si ginn am Klass Header spezifizéiert a kënne wéi regulär Variablen am Klassekierper benotzt ginn. Parameter Wäerter ginn uginn wann Dir d'Klass am Manifest benotzt.

De Parameter kann op e Standardwäert gesat ginn. Wann e Parameter kee Standardwäert huet an de Wäert net festgeluecht gëtt wann se benotzt gëtt, verursaacht et e Kompiléierungsfehler.

Loosst eis d'Klass aus dem Beispill hei uewen parametriséieren an zwee Parameteren addéieren: déi éischt, erfuerderlech, ass de Wee fir d'Konfiguratioun, an déi zweet, fakultativ, ass den Numm vum Package mat nginx (an Debian, zum Beispill, ginn et Packagen 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',   # задаём параметры класса точно так же, как параметры для других ресурсов
  }
}

An Puppet gi Variabelen getippt. Iessen vill daten Zorte. Datentypen ginn typesch benotzt fir Parameterwäerter ze validéieren, déi u Klassen an Definitioune weiderginn. Wann de passéierte Parameter net dem spezifizéierte Typ entsprécht, geschitt e Kompiléierungsfehler.

Den Typ gëtt direkt virum Parameternumm geschriwwe:

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

Klassen: enthalen Klassennumm vs Klass {'Classname':}

All Klass ass eng Ressource vun Typ Klass. Wéi mat all aner Ressource, kann et net zwee Instanzen vun der selwechter Klass op der selwechter Node ginn.

Wann Dir probéiert eng Klass op déi selwecht Node zweemol benotzt class { 'classname':} (keen Ënnerscheed, mat verschiddene oder identesche Parameteren), et gëtt e Kompiléierungsfehler. Awer wann Dir eng Klass am Ressourcestil benotzt, kënnt Dir direkt all seng Parameteren am Manifest setzen.

Allerdéngs, wann Dir benotzt include, da kann d'Klass esou oft bäigefüügt ginn wéi gewënscht. D'Tatsaach ass dat include ass eng idempotent Funktioun déi iwwerpréift ob eng Klass an de Verzeichnis bäigefüügt gouf. Wann d'Klass net am Verzeechnes ass, füügt se et derbäi, a wann et scho gëtt, mécht se näischt. Mä am Fall vun benotzen include Dir kënnt net Klass Parameteren während Klass Deklaratioun Formatioun - all néideg Parameteren muss an engem externen Daten Quell gesat ginn - Hiera oder ENC. Mir wäerten iwwer hinnen am nächsten Artikel schwätzen.

Definéiert

Wéi am virege Block gesot gouf, kann déi selwecht Klass net méi wéi eemol op engem Node präsent sinn. Wéi och ëmmer, an e puer Fäll musst Dir fäeg sinn deeselwechte Codeblock mat verschiddene Parameteren um selwechten Node ze benotzen. An anere Wierder, et gëtt e Besoin fir eng eegen Ressourcentyp.

Zum Beispill, fir de PHP Modul ze installéieren, maache mir déi folgend an Avito:

  1. Installéiert de Package mat dësem Modul.
  2. Loosst eis eng Konfiguratiounsdatei fir dëse Modul erstellen.
  3. Mir erstellen e Symlink op d'Konfiguratioun fir php-fpm.
  4. Mir erstellen e Symlink zu der Configuratioun fir php cli.

An esou Fäll, engem Design wéi definéieren (definéieren, definéiert Typ, definéiert Ressourcetyp). A Define ass ähnlech wéi eng Klass, awer et ginn Differenzen: éischtens, all Define ass eng Ressourcetyp, net eng Ressource; zweetens, all Definitioun huet eng implizit Parameter $title, wou de Ressource Numm geet wann et deklaréiert ass. Just wéi am Fall vu Klassen, muss fir d'éischt eng Definitioun beschriwwe ginn, duerno kann se benotzt ginn.

E vereinfacht Beispill mat engem Modul fir 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' }
}

Deen einfachste Wee fir den Duplikat Deklaratiounsfehler ze fangen ass am Definéieren. Dëst geschitt wann eng Definitioun eng Ressource mat engem konstante Numm huet, an et ginn zwee oder méi Instanzen vun dëser Definitioun op e puer Node.

Et ass einfach Iech selwer vun dësem ze schützen: all Ressourcen an der Definitioun mussen en Numm hunn ofhängeg vun $title. Eng Alternativ ass idempotent Zousatz vu Ressourcen am einfachsten Fall ass et genuch fir d'Ressourcen déi gemeinsam sinn fir all Instanzen vun der Definitioun an eng separat Klass ze réckelen an dës Klass an der Definitioun ze enthalen - Funktioun; include idempotent.

Et ginn aner Weeër fir Idempotenz z'erreechen wann Dir Ressourcen bäidréit, nämlech d'Benotzung vu Funktiounen defined и ensure_resources, mee ech wäert Iech doriwwer am nächsten Episod soen.

Ofhängegkeeten an Notifikatiounen fir Klassen an Definitiounen

Klassen an Definitioune fügen déi folgend Regele fir Ofhängegkeeten an Notifikatiounen un:

  • Ofhängegkeet vun enger Klass / definéieren gëtt Ofhängegkeeten op all Ressourcen vun der Klass / definéieren;
  • eng Klass / definéieren Ofhängegkeet gëtt Ofhängegkeeten op all Klass / definéieren Ressourcen;
  • Klass / definéieren Notifikatioun matdeelt all Ressourcen vun der Klass / definéieren;
  • Klass / definéieren Abonnement abonnéiert op all Ressourcen vun der Klass / definéieren.

Bedingungsvoll Aussoen a Selektor

Dokumentatioun hei.

if

Et ass einfach hei:

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

ausser

ausser wann et ëmgedréint ass: de Block vum Code gëtt ausgefouert wann den Ausdrock falsch ass.

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

Fall

Hei ass och näischt komplizéiert. Dir kënnt reegelméisseg Wäerter benotzen (Strings, Zuelen, asw.), Regelméisseg Ausdréck, an Datentypen als Wäerter.

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

Wieler

E Selektor ass e Sproochkonstruktioun ähnlech wéi case, awer amplaz e Block vu Code auszeféieren, gëtt et e Wäert zréck.

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

Modul

Wann d'Konfiguratioun kleng ass, kann et einfach an engem Manifest gehale ginn. Awer wat méi Konfiguratioune mir beschreiwen, wat méi Klassen an Wirbelen et am Manifest sinn, et wiisst, an et gëtt onbequem fir mat ze schaffen.

Zousätzlech gëtt et de Problem vum Code Wiederverwendung - wann all de Code an engem Manifest ass, ass et schwéier dëse Code mat aneren ze deelen. Fir dës zwee Problemer ze léisen, huet Puppet eng Entitéit genannt Moduler.

Modul - Dëst sinn Sätze vu Klassen, Definitiounen an aner Puppet-Entitéiten, déi an engem separaten Verzeechnes gesat ginn. An anere Wierder, e Modul ass en onofhängegt Stéck Puppet Logik. Zum Beispill kann et e Modul sinn fir mat nginx ze schaffen, an et wäert enthalen wat an nëmmen wat gebraucht gëtt fir mat nginx ze schaffen, oder et kann e Modul sinn fir mat PHP ze schaffen, a sou weider.

Moduler sinn versioned, an Ofhängegkeete vun Moduler op all aner sinn och ënnerstëtzt. Et gëtt en oppene Repository vu Moduler - Puppet Forge.

Op der Marionettenserver sinn Moduler am Moduler Ënnerverzeechnes vum Root-Verzeichnis. Bannen an all Modul gëtt et e Standard Verzeechnes Schema - Manifestatiounen, Dateien, Templates, Lib, a sou weider.

Dateistruktur an engem Modul

D'Wurzel vum Modul kann déi folgend Verzeichnisser mat beschreiwende Nimm enthalen:

  • manifests - et enthält Manifestatiounen
  • files - et enthält Dateien
  • templates - et enthält Templates
  • lib - et enthält Ruby Code

Dëst ass net eng komplett Lëscht vu Verzeichnisser a Dateien, awer et ass genuch fir dësen Artikel fir de Moment.

Nimm vun Ressourcen an Nimm vun Fichieren am Modul

Dokumentatioun hei.

Ressourcen (Klassen, Definitiounen) an engem Modul kënnen net genannt ginn wéi Dir wëllt. Zousätzlech gëtt et eng direkt Korrespondenz tëscht dem Numm vun enger Ressource an dem Numm vun der Datei an där Puppet no enger Beschreiwung vun där Ressource sicht. Wann Dir d'Benennungsregele verletzt, da wäert Puppet einfach d'Ressourcebeschreiwung net fannen, an Dir kritt e Kompiléierungsfehler.

D'Regele sinn einfach:

  • All Ressourcen an engem Modul mussen am Modul Nummraum sinn. Wann de Modul genannt gëtt foo, da sollen all Ressourcen an et genannt ginn foo::<anything>, oder just foo.
  • D'Ressource mam Numm vum Modul muss an der Datei sinn init.pp.
  • Fir aner Ressourcen ass de Dateinummschema wéi follegt:
    • de Präfix mam Modulnumm gëtt verworf
    • all duebel Colons, wann iwwerhaapt, gi mat Schnëtt ersat
    • Verlängerung gëtt dobäi .pp

Ech wäert mat engem Beispill demonstréieren. Loosst d'soen ech schreiwen e Modul nginx. Et enthält déi folgend Ressourcen:

  • класс nginx am Manifest beschriwwen init.pp;
  • класс nginx::service am Manifest beschriwwen service.pp;
  • definéieren nginx::server am Manifest beschriwwen server.pp;
  • definéieren nginx::server::location am Manifest beschriwwen server/location.pp.

Schablounen

Sécher wësst Dir selwer wat Templates sinn, ech wäert se net am Detail hei beschreiwen. Mee ech loossen et just am Fall Link op Wikipedia.

Wéi benotzen ech Schabloune: D'Bedeitung vun enger Schabloun kann mat enger Funktioun erweidert ginn template, déi de Wee op d'Schabloun passéiert ass. Fir Ressourcen vun Typ Fichier zesumme mam Parameter benotzt content. Zum Beispill, wéi dëst:

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

Vue Wee <modulename>/<filename> implizéiert Fichier <rootdir>/modules/<modulename>/templates/<filename>.

Zousätzlech gëtt et eng Funktioun inline_template - et kritt den Templatetext als Input, net den Dateinumm.

Bannent Templates kënnt Dir all Puppet Variabelen am aktuellen Ëmfang benotzen.

Puppet ënnerstëtzt Templates am ERB an EPP Format:

Kuerz iwwer ERB

Kontroll Strukturen:

  • <%= ВЫРАЖЕНИЕ %> - setzt de Wäert vum Ausdrock an
  • <% ВЫРАЖЕНИЕ %> - Berechent de Wäert vun engem Ausdrock (ouni et anzeginn). Conditional Aussoen (wann) a Loops (all) ginn normalerweis hei.
  • <%# КОММЕНТАРИЙ %>

Ausdréck an ERB ginn am Ruby geschriwwen (ERB ass tatsächlech Embedded Ruby).

Fir Zougang zu Variabelen aus dem Manifest ze kréien, musst Dir addéieren @ zu der Variabel Numm. Fir eng Linn Paus ewechzehuelen, datt no engem Kontroll Konstruktioun schéngt, Dir musst e Feierowend Tag benotzen -%>.

Beispill fir d'Schabloun ze benotzen

Loosst eis soen datt ech e Modul schreiwen fir ZooKeeper ze kontrolléieren. D'Klass verantwortlech fir d'Konfiguratioun ze kreéieren gesäit sou eppes aus:

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'),
  }
}

An déi entspriechend Schabloun zoo.cfg.erb - Also:

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

Fakten a Built-in Variablen

Oft hänkt de spezifeschen Deel vun der Konfiguratioun vun deem wat am Moment um Node geschitt. Zum Beispill, jee no wéi eng Debian Verëffentlechung ass, musst Dir eng oder aner Versioun vum Package installéieren. Dir kënnt all dëst manuell iwwerwaachen, Manifestatiounen nei schreiwen wann d'Noden änneren. Mä dëst ass net eng sérieux Approche ass vill besser.

Fir Informatiounen iwwer Noden ze kréien, huet Puppet e Mechanismus genannt Fakten. Fakten - Dëst ass Informatioun iwwer den Node, verfügbar a Manifestatiounen a Form vun normale Variablen am globalen Nummraum. Zum Beispill, Hostnumm, Betribssystem Versioun, Prozessor Architektur, Lëscht vun Benotzer, Lëscht vun Reseau Schnëttplazen an hir Adressen, a vill, vill méi. Fakten sinn a Manifestatiounen a Templates als regulär Variabelen verfügbar.

E Beispill fir mat Fakten ze schaffen:

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

Formell gesinn huet e Fakt en Numm (String) an e Wäert (verschidde Zorte si verfügbar: Strings, Arrays, Dictionnairen). Iessen Set vun agebaute Fakten. Dir kënnt och Är eege schreiwen. Fakten Sammler ginn beschriwwen wéi Funktiounen am Ruby, oder wéi ausféierbar Dateien. Fakten kënnen och an der Form presentéiert ginn Textdateien mat Daten op den Noden.

Während der Operatioun kopéiert d'Puppet Agent fir d'éischt all verfügbar Fakten Sammler vum Pappetserver op den Node, duerno lancéiert se se a schéckt déi gesammelt Fakten op de Server; Duerno fänkt de Server un de Katalog ze kompiléieren.

Fakten a Form vun ausführbaren Dateien

Esou Fakten sinn an Moduler am Verzeechnes gesat facts.d. Natierlech mussen d'Dateien ausführbar sinn. Wann se lafen, musse se Informatioun op Standardoutput an entweder YAML oder Schlëssel = Wäert Format ausginn.

Vergiesst net datt d'Fakten fir all Noden gëllen, déi vum Poppet Server kontrolléiert ginn, op deen Äre Modul ofgebaut gëtt. Dofir, am Skript, passt op fir ze kontrolléieren ob de System all Programmer an Dateien huet déi néideg sinn fir datt Äre Fakt funktionnéiert.

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

Rubin Fakten

Esou Fakten sinn an Moduler am Verzeechnes gesat 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

Text Fakten

Esou Fakte ginn op Noden am Verzeechnes gesat /etc/facter/facts.d an alen Puppet oder /etc/puppetlabs/facts.d an der neier Puppet.

examplefact=examplevalue
---
examplefact2: examplevalue2
anotherfact: anothervalue

Gitt op d'Fakten

Et ginn zwou Weeër fir d'Fakten unzegoen:

  • duerch d'Wörterbuch $facts: $facts['fqdn'];
  • benotzt de Faktnumm als Variabelnumm: $fqdn.

Et ass am beschten e Wierderbuch ze benotzen $facts, oder nach besser, de globale Nummraum uginn ($::facts).

Hei ass déi entspriechend Sektioun vun der Dokumentatioun.

Built-in Variablen

Nieft de Fakten gëtt et och puer Verännerlechen, verfügbar am globalen Nummraum.

  • vertraut Fakten - Variablen déi aus dem Client säi Certificat geholl ginn (well de Certificat normalerweis op engem Poppet Server ausgestallt gëtt, kann den Agent net nëmmen säin Zertifika huelen an änneren, sou datt d'Variablen "vertrauen"): den Numm vum Zertifika, den Numm vum Host an Domain, Extensiounen vum Zertifika.
  • Server Fakten - Variablen am Zesummenhang mat Informatioun iwwer de Server - Versioun, Numm, Server IP Adress, Ëmfeld.
  • Agent Fakten - Verännerlechen direkt vun Marionetten-Agent dobäi, an net duerch Fakt - Zertifikat Numm, Agent Versioun, Marionett Versioun.
  • Meeschtesch Verännerlechen - Pappetmaster Verännerlechen (sic!). Et ass ongeféier d'selwecht wéi an Server Fakten, plus Konfiguratiounsparameter Wäerter sinn verfügbar.
  • Compiler Verännerlechen - Compiler Variabelen déi an all Ëmfang ënnerscheeden: den Numm vum aktuelle Modul an den Numm vum Modul an deem den aktuellen Objet zougänglech war. Si kënne benotzt ginn, zum Beispill, fir ze kontrolléieren ob Är privat Klassen net direkt vun anere Moduler benotzt ginn.

Zousaz 1: wéi lafen an debuggen all dëst?

Den Artikel enthält vill Beispiller vu Poppencode, awer huet eis guer net gesot wéi Dir dëse Code leeft. Ma, ech korrigéiere mech.

En Agent ass genuch fir Puppet ze lafen, awer fir déi meescht Fäll brauch Dir och e Server.

Agent

Op d'mannst zënter Versioun 5, Puppet-Agent Packagen aus offiziell Puppetlabs Repository enthalen all Ofhängegkeeten (Ruby an déi entspriechend Edelsteng), also et gi keng Installatiounsschwieregkeeten (ech schwätzen iwwer Debian-baséiert Verdeelungen - mir benotzen keng RPM-baséiert Verdeelungen).

Am einfachsten Fall, fir d'Puppetkonfiguratioun ze benotzen, ass et genuch fir den Agent am serverlosen Modus ze starten: virausgesat datt de Marionettcode op den Node kopéiert gëtt, start 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

Et ass natierlech besser de Server opzestellen an Agenten op den Noden am Daemon Modus ze lafen - dann eemol all hallef Stonn wäerte se d'Konfiguratioun applizéieren déi vum Server erofgeluede gëtt.

Dir kënnt de Push-Modell vun der Aarbecht imitéieren - gitt op den Node an deem Dir interesséiert sidd a fänkt un sudo puppet agent -t. Schlëssel -t (--test) enthält tatsächlech verschidde Méiglechkeeten, déi individuell ageschalt kënne ginn. Dës Optiounen enthalen déi folgend:

  • lafen net am Daemon Modus (par défaut fänkt den Agent am Daemon Modus un);
  • auszeschalten nodeems de Katalog ugewannt gouf (par défaut wäert den Agent weider schaffen an d'Konfiguratioun eemol all hallef Stonn uwenden);
  • schreiwen eng detailléiert Aarbecht Log;
  • weisen Ännerungen an Fichieren.

Den Agent huet en Operatiounsmodus ouni Ännerungen - Dir kënnt et benotzen wann Dir net sécher sidd datt Dir déi richteg Konfiguratioun geschriwwen hutt a wëllt iwwerpréiwen wat genau den Agent während der Operatioun ännert. Dëse Modus gëtt vum Parameter aktivéiert --noop op der Kommandozeil: sudo puppet agent -t --noop.

Zousätzlech kënnt Dir den Debugging-Logbuch vun der Aarbecht aktivéieren - an der Marionett schreift iwwer all d'Aktiounen déi se ausféiert: iwwer d'Ressource déi se am Moment veraarbecht, iwwer d'Parameter vun dëser Ressource, iwwer wéi eng Programmer et lancéiert. Natierlech ass dëst e Parameter --debug.

Server

Ech wäert de komplette Setup vum Pappetserver net berücksichtegen an de Code an dësem Artikel z'installéieren, ech wäert nëmme soen datt et aus der Këscht eng voll funktionell Versioun vum Server ass, déi keng zousätzlech Konfiguratioun erfuerdert fir mat enger klenger Zuel ze schaffen; Wirbelen (soen, bis zu honnert). Eng méi grouss Zuel vu Wirbelen erfuerdert Tuning - Par défaut lancéiert Puppetserver net méi wéi véier Aarbechter, fir méi Leeschtung musst Dir hir Zuel erhéijen an vergiesst net d'Erënnerungsgrenzen ze erhéijen, soss wäert de Server Dreck sammelen déi meescht vun der Zäit.

Code Deployment - wann Dir et séier an einfach braucht, da kuckt (op r10k)[https://github.com/puppetlabs/r10k], fir kleng Installatiounen soll et relativ genuch sinn.

Addendum 2: Coding Richtlinnen

  1. Place all Logik an Klassen an Definitiounen.
  2. Halt Klassen an Definitiounen a Moduler, net a Manifestatiounen déi Noden beschreiwen.
  3. Benotzt d'Fakten.
  4. Maacht keng Ifs baséiert op Hostnumm.
  5. Fillt Iech gratis Parameteren fir Klassen an Definitiounen ze addéieren - dëst ass besser wéi implizit Logik verstoppt am Kierper vun der Klass / definéieren.

Ech erkläre firwat ech recommandéieren dëst am nächsten Artikel ze maachen.

Konklusioun

Loosst eis mat der Aféierung ofschléissen. Am nächsten Artikel wäert ech Iech iwwer Hiera, ENC an PuppetDB soen.

Nëmme registréiert Benotzer kënnen un der Ëmfro deelhuelen. Umellen, wann ech glift.

Tatsächlech gëtt et vill méi Material - ech kann Artikelen iwwer déi folgend Themen schreiwen, stëmmen iwwer dat wat Dir interesséiert wier ze liesen:

  • 59,1%Fortgeschratt Marionettekonstruktiounen - e puer nächste-Niveau Schäiss: Loops, Mapping an aner Lambda Ausdrock, Ressource Sammler, exportéiert Ressourcen an Inter-Host Kommunikatioun iwwer Puppet, Tags, Ubidder, abstrakt Datentypen.13
  • 31,8%"I'm my mother's admin" oder wéi mir zu Avito Frënn mat e puer Poppet-Server vu verschiddene Versioune gemaach hunn, an am Prinzip den Deel iwwer d'Administratioun vum Poppet-Server.7
  • 81,8%Wéi schreiwen mir Poppentheater Code: Instrumentatioun, Dokumentatioun, Testen, CI / CD.18

22 Benotzer hunn gestëmmt. 9 Benotzer hu sech enthalen.

Source: will.com