Marionette - Codierungsstil

In Puppet definiert der Codierungsstil alle Standards, denen Sie folgen müssen, wenn Sie versuchen, die Infrastruktur in der Maschinenkonfiguration in einen Code umzuwandeln. Puppet arbeitet und führt alle definierten Aufgaben mit Ressourcen aus.

Die Sprachdefinition von Puppet hilft bei der strukturierten Angabe aller Ressourcen, die für die Verwaltung aller zu verwaltenden Zielcomputer erforderlich sind. Puppet verwendet Ruby als Codierungssprache, die über mehrere integrierte Funktionen verfügt, die es sehr einfach machen, Dinge mit einer einfachen Konfiguration auf der Codeseite zu erledigen.

Grundeinheiten

Puppet verwendet mehrere grundlegende Codierungsstile, die leicht zu verstehen und zu verwalten sind. Es folgt eine Liste von wenigen.

Ressourcen

In Puppet werden Ressourcen als grundlegende Modellierungseinheit bezeichnet, mit der jedes Zielsystem verwaltet oder geändert wird. Die Ressourcen decken alle Aspekte eines Systems ab, z. B. Datei, Dienst und Paket. Puppet verfügt über eine integrierte Funktion, mit der Benutzer oder Entwickler benutzerdefinierte Ressourcen entwickeln können, die bei der Verwaltung einer bestimmten Einheit einer Maschine hilfreich sind

In Puppet werden alle Ressourcen entweder mithilfe von zusammengefasst “define” oder “classes”. Diese Aggregationsfunktionen helfen bei der Organisation eines Moduls. Im Folgenden finden Sie eine Beispielressource, die aus mehreren Typen, einem Titel und einer Liste von Attributen besteht, mit denen Puppet mehrere Attribute unterstützen kann. Jede Ressource in Puppet hat einen eigenen Standardwert, der bei Bedarf überschrieben werden kann.

Beispiel für eine Puppenressource für eine Datei

Im folgenden Befehl versuchen wir, eine Berechtigung für eine bestimmte Datei anzugeben.

file {  
   '/etc/passwd': 
   owner => superuser, 
   group => superuser, 
   mode => 644, 
}

Immer wenn der obige Befehl auf einem Computer ausgeführt wird, wird überprüft, ob die passwd-Datei im System wie beschrieben konfiguriert ist. Die Datei vor: Doppelpunkt ist der Titel der Ressource, die in anderen Teilen der Puppet-Konfiguration als Ressource bezeichnet werden kann.

Angabe des lokalen Namens zusätzlich zum Titel

file { 'sshdconfig': 
   name => $operaSystem ? { 
      solaris => '/usr/local/etc/ssh/sshd_config', 
      default => '/etc/ssh/sshd_config', 
   }, 
   owner => superuser, 
   group => superuser, 
   mode => 644, 
}

Durch die Verwendung des Titels, der immer derselbe ist, ist es sehr einfach, Dateiressourcen in der Konfiguration zu referenzieren, ohne die betriebssystembezogene Logik wiederholen zu müssen.

Ein anderes Beispiel könnte die Verwendung eines Dienstes sein, der von einer Datei abhängt.

service { 'sshd': 
   subscribe => File[sshdconfig], 
}

Mit dieser Abhängigkeit kann die sshd Der Dienst wird immer neu gestartet, sobald der sshdconfigDateiänderungen. Der Punkt, an den man sich hier erinnern sollte, istFile[sshdconfig] ist eine Deklaration als Datei wie in Kleinbuchstaben, aber wenn wir sie ändern FILE[sshdconfig] dann wäre es eine Referenz gewesen.

Ein grundlegender Punkt, den Sie beim Deklarieren einer Ressource berücksichtigen müssen, ist, dass sie nur einmal pro Konfigurationsdatei deklariert werden kann. Das mehrmalige Wiederholen der Deklaration derselben Ressource führt zu einem Fehler. Durch dieses grundlegende Konzept stellt Puppet sicher, dass die Konfiguration gut modelliert ist.

Wir haben sogar die Möglichkeit, die Ressourcenabhängigkeit zu verwalten, was bei der Verwaltung mehrerer Beziehungen hilfreich ist.

service { 'sshd': 
   require => File['sshdconfig', 'sshconfig', 'authorized_keys']
}

Metaparameter

Metaparameter werden in Puppet als globale Parameter bezeichnet. Eines der Hauptmerkmale von Metaparameter ist, dass es mit jeder Art von Ressource in Puppet funktioniert.

Ressourcenstandard

Wenn ein Standardwert für Ressourcenattribute definiert werden muss, stellt Puppet eine Reihe von Syntax zur Archivierung bereit, wobei eine großgeschriebene Ressourcenspezifikation ohne Titel verwendet wird.

Wenn Sie beispielsweise den Standardpfad aller ausführbaren Dateien festlegen möchten, können Sie dies mit dem folgenden Befehl tun.

Exec { path => '/usr/bin:/bin:/usr/sbin:/sbin' } 
exec { 'echo Testing mataparamaters.': }

Im obigen Befehl legt die erste Anweisung Exec den Standardwert für die Exec-Ressource fest. Für die Exec-Ressource ist ein vollständig qualifizierter Pfad oder ein Pfad erforderlich, der wie eine ausführbare Datei aussieht. Damit kann ein einzelner Standardpfad für die gesamte Konfiguration definiert werden. Die Standardeinstellungen funktionieren mit jedem Ressourcentyp in Puppet.

Standardwerte sind keine globalen Werte, sie wirken sich jedoch nur auf den Bereich aus, in dem sie definiert sind, oder auf die nächste Variable. Wenn man definieren willdefault Für eine vollständige Konfiguration definieren wir dann die default und die Klasse im nächsten Abschnitt.

Ressourcensammlungen

Aggregation ist eine Methode, um Dinge zusammen zu sammeln. Puppet unterstützt ein sehr leistungsfähiges Konzept der Aggregation. In Puppet wird die Aggregation zum Gruppieren von Ressourcen verwendet, die die grundlegende Einheit von Puppet bilden. Dieses Konzept der Aggregation in Puppet wird mithilfe von zwei leistungsstarken Methoden erreicht, die als bekannt sindclasses und definition.

Klassen und Definition

Klassen sind für die Modellierung der grundlegenden Aspekte des Knotens verantwortlich. Sie können sagen, dass der Knoten ein Webserver ist und dieser bestimmte Knoten einer von ihnen. In Puppet sind Programmierklassen Singleton-Klassen und können einmal pro Knoten ausgewertet werden.

Die Definition hingegen kann auf einem einzelnen Knoten mehrfach verwendet werden. Sie funktionieren ähnlich, wie man seinen eigenen Puppentyp mit der Sprache erstellt hat. Sie werden so erstellt, dass sie jedes Mal mehrfach mit unterschiedlichen Eingaben verwendet werden können. Dies bedeutet, dass man variable Werte an die Definition übergeben kann.

Unterschied zwischen Klasse und Definition

Der einzige wesentliche Unterschied zwischen einer Klasse und einer Definition besteht darin, dass beim Definieren der Gebäudestruktur und beim Zuweisen von Ressourcen die Klasse nur einmal pro Knoten ausgewertet wird, wobei andererseits eine Definition auf demselben einzelnen Knoten mehrmals verwendet wird.

Klassen

Klassen in Puppet werden mit dem Schlüsselwort class eingeführt, und der Inhalt dieser bestimmten Klasse wird in geschweifte Klammern eingeschlossen, wie im folgenden Beispiel gezeigt.

class unix { 
   file { 
      '/etc/passwd': 
      owner => 'superuser', 
      group => 'superuser', 
      mode => 644; 
      '/etc/shadow': 
      owner => 'vipin', 
      group => 'vipin', 
      mode => 440; 
   } 
}

Im folgenden Beispiel haben wir eine kurze Hand verwendet, die der obigen ähnlich ist.

class unix { 
   file { 
      '/etc/passwd': 
      owner => 'superuser', 
      group => 'superuser', 
      mode => 644; 
   }  
   
   file {'/etc/shadow': 
      owner => 'vipin', 
      group => 'vipin', 
      mode => 440; 
   } 
}

Vererbung in Puppenklassen

In Puppet wird standardmäßig das OOP-Konzept der Vererbung unterstützt, bei dem Klassen die Funktionalität der vorherigen Klasse erweitern können, ohne das vollständige Codebit in der neu erstellten Klasse erneut zu kopieren und einzufügen. Durch Vererbung kann die Unterklasse die in der übergeordneten Klasse definierten Ressourceneinstellungen überschreiben. Eine wichtige Sache, die Sie bei der Verwendung der Vererbung beachten sollten, ist, dass eine Klasse nur Features von nur einer übergeordneten Klasse erben kann, nicht von mehr als einer.

class superclass inherits testsubclass { 
   File['/etc/passwd'] { group => wheel } 
   File['/etc/shadow'] { group => wheel } 
}

Wenn eine in einer übergeordneten Klasse angegebene Logik rückgängig gemacht werden muss, können wir sie verwenden undef command.

class superclass inherits testsubcalss { 
   File['/etc/passwd'] { group => undef } 
}

Alternative Art der Vererbung

class tomcat { 
   service { 'tomcat': require => Package['httpd'] } 
} 
class open-ssl inherits tomcat { 
   Service[tomcat] { require +> File['tomcat.pem'] } 
}

Verschachtelte Klasse in Puppet

Puppet unterstützt das Konzept der Verschachtelung von Klassen, bei denen verschachtelte Klassen verwendet werden können, dh eine Klasse in der anderen. Dies hilft bei der Erreichung von Modularität und Umfang.

class testclass { 
   class nested { 
      file {  
         '/etc/passwd': 
         owner => 'superuser', 
         group => 'superuser', 
         mode => 644; 
      } 
   } 
} 
class anotherclass { 
   include myclass::nested 
}

Parametrisierte Klassen

In Puppet können Klassen ihre Funktionalität erweitern, um die Übergabe von Parametern an eine Klasse zu ermöglichen.

Um einen Parameter in einer Klasse zu übergeben, kann das folgende Konstrukt verwendet werden:

class tomcat($version) { 
   ... class contents ... 
}

Ein wichtiger Punkt, den Sie in Puppet beachten sollten, ist, dass Klassen mit Parametern nicht mit der Include-Funktion hinzugefügt werden, sondern dass die resultierende Klasse als Definition hinzugefügt werden kann.

node webserver { 
   class { tomcat: version => "1.2.12" } 
}

Standardwerte als Parameter in der Klasse

class tomcat($version = "1.2.12",$home = "/var/www") { 
   ... class contents ... 
}

Stages ausführen

Puppet unterstützt das Konzept der Ausführungsstufe, dh der Benutzer kann je nach Anforderung mehrere Stufen hinzufügen, um eine bestimmte Ressource oder mehrere Ressourcen zu verwalten. Diese Funktion ist sehr hilfreich, wenn der Benutzer einen komplexen Katalog entwickeln möchte. In einem komplexen Katalog verfügt man über eine große Anzahl von Ressourcen, die kompiliert werden müssen, wobei zu berücksichtigen ist, dass die Abhängigkeiten zwischen den definierten Ressourcen nicht beeinträchtigt werden sollten.

Run Stage ist sehr hilfreich beim Verwalten von Ressourcenabhängigkeiten. Dies kann durch Hinzufügen von Klassen in definierten Phasen erfolgen, in denen eine bestimmte Klasse eine Sammlung von Ressourcen enthält. Mit der Ausführungsphase garantiert Puppet, dass die definierten Phasen jedes Mal in einer bestimmten vorhersehbaren Reihenfolge ausgeführt werden, wenn der Katalog ausgeführt wird und auf einen beliebigen Puppet-Knoten angewendet wird.

Um dies zu verwenden, müssen zusätzliche Stufen über die bereits vorhandenen Stufen hinaus deklariert werden. Anschließend kann Puppet so konfiguriert werden, dass jede Stufe in einer bestimmten Reihenfolge mit derselben Syntax für Ressourcenbeziehungen verwaltet wird, bevor dies erforderlich ist “->” und “+>”. Die Beziehung garantiert dann die Reihenfolge der Klassen, die jeder Stufe zugeordnet sind.

Deklarieren zusätzlicher Stufen mit deklarativer Puppet-Syntax

stage { "first": before => Stage[main] } 
stage { "last": require => Stage[main] }

Sobald die Stufen deklariert wurden, kann eine Klasse der anderen Stufe als der Hauptstufe zugeordnet werden, die die Stufe verwendet.

class { 
   "apt-keys": stage => first; 
   "sendmail": stage => main; 
   "apache": stage => last; 
}

Alle mit der Klasse apt-key verknüpften Ressourcen werden zuerst ausgeführt. Alle Ressourcen in Sendmail sind die Hauptklasse und die mit Apache verknüpften Ressourcen sind die letzte Stufe.

Definitionen

In Puppet erfolgt das Sammeln von Ressourcen in einer beliebigen Manifestdatei entweder nach Klassen oder nach Definitionen. Definitionen sind einer Klasse in Puppet sehr ähnlich, werden jedoch mit a eingeführtdefine keyword (not class)und sie unterstützen Argumente, nicht Vererbung. Sie können mehrmals mit unterschiedlichen Parametern auf demselben System ausgeführt werden.

Wenn Sie beispielsweise eine Definition erstellen möchten, die die Quellcode-Repositorys steuert, bei denen versucht wird, mehrere Repositorys auf demselben System zu erstellen, können Sie die Definition nicht als Klasse verwenden.

define perforce_repo($path) { 
   exec {  
      "/usr/bin/svnadmin create $path/$title": 
      unless => "/bin/test -d $path", 
   } 
} 
svn_repo { puppet_repo: path => '/var/svn_puppet' } 
svn_repo { other_repo: path => '/var/svn_other' }

Der wichtigste Punkt, der hier zu beachten ist, ist, wie eine Variable mit einer Definition verwendet werden kann. Wir gebrauchen ($) Dollarzeichenvariable. Oben haben wir $ title verwendet. Definitionen können sowohl einen $ title als auch einen $ name haben, mit denen der Name und der Titel dargestellt werden können. Standardmäßig sind $ title und $ name auf denselben Wert festgelegt, es kann jedoch ein title-Attribut festgelegt und ein anderer Name als Parameter übergeben werden. $ title und $ name funktionieren nur in der Definition, nicht in Klassen oder anderen Ressourcen.

Module

Ein Modul kann als Sammlung aller Konfigurationen definiert werden, die vom Puppet-Master verwendet werden, um Konfigurationsänderungen auf einen bestimmten Puppet-Knoten (Agenten) anzuwenden. Sie werden auch als tragbare Sammlung verschiedener Arten von Konfigurationen bezeichnet, die zur Ausführung einer bestimmten Aufgabe erforderlich sind. Ein Modul kann beispielsweise alle Ressourcen enthalten, die zum Konfigurieren von Postfix und Apache erforderlich sind.

Knoten

Knoten sind ein sehr einfacher verbleibender Schritt. So passen wir das, was wir definiert haben („so sieht ein Webserver aus“), an die Maschinen an, die ausgewählt wurden, um diese Anweisungen zu erfüllen.

Die Knotendefinition sieht genau wie Klassen aus, einschließlich der unterstützenden Vererbung. Sie sind jedoch speziell, sodass der Name eines Knotens (eines verwalteten Computers, auf dem ein Puppet-Client ausgeführt wird) mit dem Puppet-Master-Daemon in der definierten Liste der Knoten angezeigt wird. Die definierten Informationen werden für den Knoten ausgewertet, und dann sendet der Knoten diese Konfiguration.

Der Knotenname kann ein kurzer Hostname oder der vollqualifizierte Domänenname (FQDN) sein.

node 'www.vipin.com' { 
   include common 
   include apache, squid 
}

Die obige Definition erstellt einen Knoten namens www.vipin.com und enthält die Klassen common, Apache und Squid

Wir können dieselbe Konfiguration an verschiedene Knoten senden, indem wir sie jeweils durch Komma trennen.

node 'www.testing.com', 'www.testing2.com', 'www3.testing.com' { 
   include testing 
   include tomcat, squid 
}

Regulärer Ausdruck für übereinstimmende Knoten

node /^www\d+$/ { 
   include testing 
}

Knotenvererbung

Der Knoten unterstützt ein begrenztes Vererbungsmodell. Wie Klassen können Knoten nur von einem anderen Knoten erben.

node 'www.testing2.com' inherits 'www.testing.com' { 
   include loadbalancer 
}

Im obigen Code erbt www.testing2.com zusätzlich zu einer zusätzlichen Loadbalancer-Klasse alle Funktionen von www.testing.com.

Erweiterte unterstützte Funktionen

Quoting- In den meisten Fällen müssen wir in Puppet keine Zeichenfolge zitieren. Jede alphanumerische Zeichenfolge, die mit einem Buchstaben beginnt, darf ohne Anführungszeichen bleiben. Es wird jedoch immer empfohlen, eine Zeichenfolge für nicht negative Werte in Anführungszeichen zu setzen.

Variable Interpolation mit Anführungszeichen

Bisher haben wir Variablen in Bezug auf die Definition erwähnt. Wenn Sie diese Variablen mit einer Zeichenfolge verwenden müssen, verwenden Sie doppelte Anführungszeichen, keine einfachen Anführungszeichen. Eine einfache Anführungszeichenfolge führt keine Variableninterpolation durch, eine doppelte Anführungszeichenfolge. Die Variable kann in Klammern gesetzt werden{} das macht sie einfacher zusammen zu verwenden und leichter zu verstehen.

$value = "${one}${two}"

Als bewährte Methode sollten für alle Zeichenfolgen, für die keine Zeichenfolgeninterpolation erforderlich ist, einfache Anführungszeichen verwendet werden.

Kapitalisierung

Die Großschreibung ist ein Prozess, der zum Referenzieren, Vererben und Festlegen von Standardattributen einer bestimmten Ressource verwendet wird. Grundsätzlich gibt es zwei grundlegende Verwendungsmöglichkeiten.

• Referencing- Auf diese Weise wird auf eine bereits erstellte Ressource verwiesen. Es wird hauptsächlich für Abhängigkeitszwecke verwendet, man muss den Namen der Ressource groß schreiben. Beispiel, erfordern => Datei [sshdconfig]

• Inheritance- Wenn Sie die Einstellung für die übergeordnete Klasse aus der Unterklasse überschreiben, verwenden Sie die Großbuchstabenversion des Ressourcennamens. Die Verwendung der Kleinbuchstabenversion führt zu einem Fehler.

• Setting Default Attribute Value - Wenn Sie die großgeschriebene Ressource ohne Titel verwenden, wird der Standardwert der Ressource festgelegt.

Arrays

Puppet ermöglicht die Verwendung von Arrays in mehreren Bereichen [Eins, zwei, drei].

Mehrere Typmitglieder, z. B. Alias ​​in der Hostdefinition, akzeptieren Arrays in ihren Werten. Eine Host-Ressource mit mehreren Aliasen sieht folgendermaßen aus.

host { 'one.vipin.com': 
   alias => [ 'satu', 'dua', 'tiga' ], 
   ip => '192.168.100.1', 
   ensure => present, 
}

Der obige Code fügt einen Host hinzu ‘one.brcletest.com’ zur Hostliste mit drei Aliasnamen ‘satu’ ‘dua’ ‘tiga’. Wenn Sie einer Ressource mehrere Ressourcen hinzufügen möchten, können Sie dies wie im folgenden Beispiel gezeigt tun.

resource { 'baz': 
   require => [ Package['rpm'], File['testfile'] ], 
}

Variablen

Puppet unterstützt wie die meisten anderen Programmiersprachen mehrere Variablen. Marionettenvariablen werden mit bezeichnet$.

$content = 'some content\n' 
file { '/tmp/testing': content => $content }

Wie bereits erwähnt, ist Puppet eine deklarative Sprache, was bedeutet, dass sich Umfang und Zuweisungsregeln von der imperativen Sprache unterscheiden. Der Hauptunterschied besteht darin, dass die Variable nicht innerhalb eines einzelnen Bereichs geändert werden kann, da sie sich auf die Reihenfolge in der Datei stützen, um den Wert einer Variablen zu bestimmen. Die Reihenfolge spielt in der deklarativen Sprache keine Rolle.

$user = root 
file {  
   '/etc/passwd': 
   owner => $user, 
} 

$user = bin 
   file {  
      '/bin': 
      owner => $user, 
      recurse => true, 
   }

Variabler Umfang

Der Variablenbereich definiert, ob alle definierten Variablen gültig sind. Wie bei den neuesten Funktionen ist Puppet derzeit dynamisch ausgerichtet, was in Puppet-Begriffen bedeutet, dass alle definierten Variablen nach ihrem Umfang und nicht nach dem Ort bewertet werden, an dem sie definiert sind.

$test = 'top' 
class Testclass { 
   exec { "/bin/echo $test": logoutput => true } 
} 

class Secondtestclass { 
   $test = 'other' 
   include myclass 
} 

include Secondtestclass

Qualifizierte Variable

Puppet unterstützt die Verwendung qualifizierter Variablen innerhalb einer Klasse oder Definition. Dies ist sehr hilfreich, wenn der Benutzer dieselbe Variable in anderen Klassen verwenden möchte, die er definiert hat oder definieren wird.

class testclass { 
   $test = 'content' 
} 

class secondtestclass { 
   $other = $myclass::test 
}

Im obigen Code wertet der Wert der Variablen $ other den Inhalt aus.

Bedingungen

Bedingungen sind Situationen, in denen der Benutzer eine Reihe von Anweisungen oder Codes ausführen möchte, wenn die definierte Bedingung oder die erforderliche Bedingung erfüllt ist. Puppet unterstützt zwei Arten von Bedingungen.

Die Auswahlbedingung, die nur innerhalb der definierten Ressourcen verwendet werden kann, um den korrekten Wert der Maschine auszuwählen.

Anweisungsbedingungen sind häufig verwendete Bedingungen im Manifest, die dazu beitragen, zusätzliche Klassen aufzunehmen, die der Benutzer in dieselbe Manifestdatei aufnehmen möchte. Definieren Sie einen bestimmten Satz von Ressourcen innerhalb einer Klasse oder treffen Sie andere strukturelle Entscheidungen.

Selektoren

Selektoren sind nützlich, wenn der Benutzer ein Ressourcenattribut und Variablen angeben möchte, die sich von den Standardwerten aufgrund der Fakten oder anderer Variablen unterscheiden. In Puppet funktioniert der Selektorindex wie ein mehrwertiger Drei-Wege-Operator. Selektoren können auch die benutzerdefinierten Standardwerte ohne Werte definieren, die im Manifest definiert sind und der Bedingung entsprechen.

$owner = $Sysoperenv ? { 
   sunos => 'adm', 
   redhat => 'bin', 
   default => undef, 
}

In späteren Versionen von Puppet 0.25.0 können Selektoren als reguläre Ausdrücke verwendet werden.

$owner = $Sysoperenv ? { 
   /(Linux|Ubuntu)/ => 'bin', 
   default => undef, 
}

Im obigen Beispiel der Selektor $Sysoperenv Der Wert entspricht entweder Linux oder Ubuntu. Dann ist der Bin das ausgewählte Ergebnis. Andernfalls wird der Benutzer als undefiniert festgelegt.

Anweisungsbedingung

Die Anweisungsbedingung ist eine andere Art von bedingter Anweisung in Puppet, die der Switch-Case-Bedingung im Shell-Skript sehr ähnlich ist. Hierbei werden mehrere case-Anweisungen definiert und die angegebenen Eingabewerte mit jeder Bedingung abgeglichen.

Die case-Anweisung, die der angegebenen Eingabebedingung entspricht, wird ausgeführt. Diese case-Anweisungsbedingung hat keinen Rückgabewert. In Puppet wird in einem sehr häufigen Anwendungsfall für Bedingungsanweisungen eine Reihe von Codebits ausgeführt, die auf dem zugrunde liegenden Betriebssystem basieren.

case $ Sysoperenv { 
   sunos: { include solaris }  
   redhat: { include redhat }  
   default: { include generic}  
}

Case Statement kann auch mehrere Bedingungen angeben, indem sie durch ein Komma getrennt werden.

case $Sysoperenv { 
   development,testing: { include development } testing,production: { include production }
   default: { include generic }  
}

If-Else-Anweisung

Puppet unterstützt das Konzept des zustandsbasierten Betriebs. Um dies zu erreichen, bietet die If / else-Anweisung Verzweigungsoptionen basierend auf dem Rückgabewert der Bedingung. Wie im folgenden Beispiel gezeigt -

if $Filename { 
   file { '/some/file': ensure => present } 
} else { 
   file { '/some/other/file': ensure => present } 
}

Die neueste Version von Puppet unterstützt Variablenausdrücke, bei denen die if-Anweisung auch basierend auf dem Wert eines Ausdrucks verzweigen kann.

if $machine == 'production' { 
   include ssl 
} else { 
   include nginx 
}

Um mehr Vielfalt im Code zu erreichen und komplexe bedingte Operationen auszuführen, unterstützt Puppet verschachtelte if / else-Anweisungen, wie im folgenden Code gezeigt.

if $ machine == 'production' { 
   include ssl 
} elsif $ machine == 'testing' { 
   include nginx
} else { 
   include openssl 
}

Virtuelle Ressource

Virtuelle Ressourcen sind solche, die erst dann an den Client gesendet werden, wenn sie realisiert wurden.

Im Folgenden finden Sie die Syntax für die Verwendung virtueller Ressourcen in Puppet.

@user { vipin: ensure => present }

Im obigen Beispiel wird das Benutzer-Vipin virtuell definiert, um die Definition zu realisieren, die in der Sammlung verwendet werden kann.

User <| title == vipin |>

Bemerkungen

Kommentare werden in jedem Codebit verwendet, um einen zusätzlichen Knoten über eine Reihe von Codezeilen und deren Funktionalität zu erstellen. In Puppet gibt es derzeit zwei Arten von unterstützten Kommentaren.

• Kommentare im Unix-Shell-Stil. Sie können in ihrer eigenen Zeile oder in der nächsten Zeile stehen.
• Mehrzeilige Kommentare im C-Stil.

Das Folgende ist ein Beispiel für einen Kommentar im Shell-Stil.

# this is a comment

Das Folgende ist ein Beispiel für einen mehrzeiligen Kommentar.

/* 
This is a comment 
*/

Vorrang des Bedieners

Die Priorität des Puppet-Operators entspricht der Standard-Priorität in den meisten Systemen, vom höchsten zum niedrigsten.

Es folgt die Liste der Ausdrücke

• ! = nicht
• / = mal und teile
• - + = minus, plus
• << >> = Links- und Rechtsverschiebung
• ==! = = nicht gleich, gleich
• > = <=> <= größer gleich, kleiner oder gleich, größer als, kleiner als

Vergleichsausdruck

Vergleichsausdrücke werden verwendet, wenn der Benutzer eine Reihe von Anweisungen ausführen möchte, wenn die angegebene Bedingung erfüllt ist. Vergleichsausdrücke umfassen Tests auf Gleichheit unter Verwendung des Ausdrucks ==.

if $environment == 'development' { 
   include openssl 
} else { 
   include ssl 
}

Nicht gleiches Beispiel

if $environment != 'development' { 
   $otherenvironment = 'testing' 
} else { 
   $otherenvironment = 'production' 
}

Arithmetischer Ausdruck

$one = 1 
$one_thirty = 1.30 
$two = 2.034e-2 $result = ((( $two + 2) / $one_thirty) + 4 * 5.45) - 
   (6 << ($two + 4)) + (0×800 + -9)

Boolescher Ausdruck

Boolesche Ausdrücke sind mit oder und & nicht möglich.

$one = 1 
$two = 2 
$var = ( $one < $two ) and ( $one + 1 == $two )

Regulären Ausdruck

Puppet unterstützt den Abgleich regulärer Ausdrücke mit = ~ (Übereinstimmung) und! ~ (Nichtübereinstimmung).

if $website =~ /^www(\d+)\./ { 
   notice('Welcome web server #$1') 
}

Wie bei der Übereinstimmung von Groß- und Kleinschreibung und Selektor wird für jede Regex eine begrenzte Bereichsvariable erstellt.

exec { "Test": 
   command => "/bin/echo now we don’t have openssl installed on machine > /tmp/test.txt", 
   unless => "/bin/which php" 
}

In ähnlicher Weise können wir verwenden, es sei denn, der Befehl wird nicht ständig ausgeführt, mit Ausnahme des Befehls unter, sofern er nicht erfolgreich beendet wird.

exec { "Test": 
   command => "/bin/echo now we don’t have openssl installed on machine > /tmp/test.txt", 
   unless => "/bin/which php" 
}

Arbeiten mit Vorlagen

Vorlagen werden verwendet, wenn eine vordefinierte Struktur gewünscht wird, die über mehrere Module in Puppet verwendet wird, und diese Module auf mehrere Computer verteilt werden. Der erste Schritt zur Verwendung der Vorlage besteht darin, eine zu erstellen, die den Vorlageninhalt mit Vorlagenmethoden rendert.

file { "/etc/tomcat/sites-available/default.conf": 
   ensure => "present", 
   content => template("tomcat/vhost.erb")  
}

Puppet macht beim Umgang mit lokalen Dateien nur wenige Annahmen, um Organisation und Modularität durchzusetzen. Puppet sucht nach der Vorlage vhost.erb im Ordner apache / templates im Modulverzeichnis.

Dienste definieren und auslösen

In Puppet gibt es eine Ressource namens "Dienst", mit der der Lebenszyklus aller Dienste verwaltet werden kann, die auf einem bestimmten Computer oder einer bestimmten Umgebung ausgeführt werden. Serviceressourcen werden verwendet, um sicherzustellen, dass Services initialisiert und aktiviert werden. Sie werden auch für den Neustart des Dienstes verwendet.

Zum Beispiel in der vorherigen Vorlage von Tomcat, in der wir den virtuellen Apache-Host festgelegt haben. Wenn Sie sicherstellen möchten, dass Apache nach einem virtuellen Hostwechsel neu gestartet wird, müssen Sie mit dem folgenden Befehl eine Serviceressource für den Apache-Service erstellen.

service { 'tomcat': 
   ensure => running, 
   enable => true 
}

Bei der Definition der Ressourcen müssen wir die Benachrichtigungsoption einschließen, um den Neustart auszulösen.

file { "/etc/tomcat/sites-available/default.conf": 
   ensure => "present", 
   content => template("vhost.erb"), 
   notify => Service['tomcat']  
}