Einführung
Nach dem Einrichten von Puppet in einer Agent / Master-Konfiguration benötigen Sie möglicherweise Hilfe beim Schreiben von Puppet-Manifesten und -Modulen. Um Puppet effektiv nutzen zu können, müssen Sie wissen, wie Manifeste und Module aufgebaut sind. Dieses Tutorial behandelt die Grundlagen des Puppet-Codes und zeigt Ihnen, wie Sie Manifeste und Module erstellen, die Ihnen den Einstieg in die Verwaltung Ihrer Serverumgebung mit Puppet erleichtern. Wir zeigen drei verschiedene Möglichkeiten, wie Sie mit Puppet einen LAMP-Stack auf einem Ubuntu 14.04 VPS konfigurieren können.
Voraussetzungen
Bevor Sie mit diesem Tutorial beginnen können, müssen Sie über ein Setup für Agenten / Master-Puppets verfügen. Wenn Sie dies noch nicht haben, folgen Sie diesem Tutorial:How To Install Puppet To Manage Your Server Infrastructure.
Sie müssen außerdem in der Lage sein, mindestens einen neuen VPS zu erstellen, der als Puppet-Agentenknoten fungiert, den der Puppet-Master verwalten wird.
Erstellen Sie einen neuen Agentenknoten
Erstellen Sie ein neues Ubuntu 14.04 VPS mit dem Namen "lamp-1",add it as a Puppet agent node, und signieren Sie die Zertifikatanforderung beim Puppet Master.
Puppet Code Grundlagen
Bevor Sie sich mit dem Schreiben von Puppet-Code befassen, mit dem unsere Systeme konfiguriert werden, lassen Sie uns einige der relevanten Puppet-Begriffe und -Konzepte noch einmal durchgehen.
Ressourcen
Puppencode besteht hauptsächlich ausresource declarations. Eine Ressource beschreibt etwas über den Status des Systems, beispielsweise, dass ein bestimmter Benutzer oder eine bestimmte Datei vorhanden sein oder ein Paket installiert werden soll. Hier ist ein Beispiel für eine Benutzerressourcendeklaration:
user { 'mitchell':
ensure => present,
uid => '1000',
gid => '1000',
shell => '/bin/bash',
home => '/home/mitchell'
}Ressourcendeklarationen sind wie folgt formatiert:
resource_type { 'resource_name'
attribute => value
...
}Daher beschreibt die vorherige Ressourcendeklaration eine Benutzerressource mit dem Namen "Mitchell" mit den angegebenen Attributen.
Geben Sie den folgenden Befehl ein, um alle für Puppet verfügbaren Standardressourcentypen aufzulisten:
puppet resource --typesIn diesem Lernprogramm werden einige weitere Ressourcentypen behandelt.
Manifeste
Puppenspiele werden Manifeste genannt. Manifeste bestehen aus Puppencode und ihre Dateinamen verwenden die Erweiterung.pp. Das Standard-Hauptmanifest in Puppet, das über apt installiert wird, ist/etc/puppet/manifests/site.pp.
Wenn Sie das vorausgesetzte Puppet-Tutorial befolgt haben, haben Sie bereits ein Manifest geschrieben, das eine Datei erstellt und Apache installiert. Wir werden in diesem Tutorial noch ein paar mehr schreiben.
Klassen
In Puppet sind Klassen Codeblöcke, die in einem Code an anderer Stelle aufgerufen werden können. Mit Klassen können Sie Puppet-Code wiederverwenden und das Lesen von Manifesten vereinfachen.
Klassendefinition
In einer Klassendefinition befindet sich der Code, aus dem eine Klasse besteht. Das Definieren einer Klasse stellt die Klasse für die Verwendung in Manifesten zur Verfügung, wertet jedoch nichts aus.
So wird eine Klassedefinition formatiert:
class example_class {
...
code
...
}Das Obige definiert eine Klasse mit dem Namen "example_class", und der Puppet-Code würde zwischen den geschweiften Klammern stehen.
Klassenerklärung
Eine Klassendeklaration tritt auf, wenn eine Klasse in einem Manifest aufgerufen wird. Eine Klassendeklaration weist Puppet an, den Code innerhalb der Klasse auszuwerten. Klassendeklarationen gibt es in zwei verschiedenen Varianten: normal und ressourcenschonend.
Einnormal class declaration tritt auf, wenn das Schlüsselwortinclude im Puppencode verwendet wird, wie folgt:
include example_classDies veranlasst Puppet, den Code inexample_class auszuwerten.
Einresource-like class declaration tritt auf, wenn eine Klasse wie eine Ressource deklariert wird, wie folgt:
class { 'example_class': }Durch die Verwendung von ressourcenähnlichen Klassendeklarationen können Sieclass parameters angeben, die die Standardwerte von Klassenattributen überschreiben. Wenn Sie das vorausgesetzte Lernprogramm befolgt haben, haben Sie bereits eine ressourcenähnliche Klassendeklaration ("Apache" -Klasse) verwendet, als Sie das PuppetLabs Apache-Modul zum Installieren von Apache aufhost2 verwendet haben:
node 'host2' {
class { 'apache': } # use apache module
apache::vhost { 'example.com': # define vhost resource
port => '80',
docroot => '/var/www/html'
}
}Nachdem Sie sich mit Ressourcen, Manifesten und Klassen vertraut gemacht haben, möchten Sie mehr über Module erfahren.
Module
Ein Modul ist eine Sammlung von Manifesten und Daten (wie Fakten, Dateien und Vorlagen), die eine bestimmte Verzeichnisstruktur haben. Module sind nützlich, um Ihren Puppet-Code zu organisieren, da Sie Ihren Code in mehrere Manifeste aufteilen können. Es wird empfohlen, Module zu verwenden, um fast alle Puppet-Manifeste zu organisieren.
Um ein Modul zu Puppet hinzuzufügen, legen Sie es im Verzeichnis/etc/puppet/modulesab.
Wir werden die Details besprechen, die notwendig sind, um Ihr eigenes Basismodul zu schreiben. Weitere Informationen finden Sie im Referenzhandbuch fürPuppetLabs Module Fundamentals.
Manifest entwickeln
Um zu demonstrieren, wie man Puppet-Manifeste, -Klassen und -Module schreibt, verwenden wir Puppet, um den LAMP-Stack unter Ubuntu einzurichten (ähnlich dem Setup inthis tutorial). Wenn Sie noch nie einen LAMP-Stack eingerichtet haben, sollten Sie das verknüpfte Lernprogramm durchgehen, um sich mit der manuellen Einrichtung vertraut zu machen.
Aus dem LAMP-Stack-Tutorial wissen wir, dass wir einen Ubuntu 14.04-Server mit den folgendenresources wollen:
-
Apache-Paket (apache2) installiert
-
Der Apache-Dienst (apache2) wird ausgeführt
-
MySQL Server Paket (MySQL-Server) installiert
-
Der MySQL Server-Dienst (MySQL) wird ausgeführt
-
PHP5-Paket (php5) installiert
-
Eine Test-PHP-Skriptdatei (info.php)
-
Aktualisieren Sie apt, bevor Sie Pakete installieren
Die folgenden drei Abschnitte zeigen verschiedene Möglichkeiten, wie Puppet verwendet werden kann, um ähnliche Ergebnisse zu erzielen. Dies ist ein funktionierender LAMP-Server. Das erste Beispiel zeigt, wie ein grundlegendes Manifest geschrieben wird, das sich in einer Datei befindet. Das zweite Beispiel zeigt, wie eine Klasse und ein Modul erstellt und verwendet werden, wobei auf dem im ersten Beispiel entwickelten Manifest aufgebaut wird. Das dritte Beispiel zeigt schließlich, wie bereits vorhandene, öffentlich verfügbare Module verwendet werden, um schnell und einfach einen ähnlichen LAMP-Stack einzurichten. Wenn Sie alle drei Beispiele zu Lernzwecken ausprobieren möchten, empfehlen wir, jedes Mal mit einem neuen VPS (wie inprerequisites beschrieben) zu beginnen.
Beispiel 1: Installieren Sie LAMP mit einem einzigen Manifest
Wenn Sie noch nie ein Puppenmanifest geschrieben haben, ist dieses Beispiel ein guter Ausgangspunkt. Das Manifest wird auf einem Puppet-Agentenknoten entwickelt und überpuppet apply ausgeführt, sodass kein Agent / Master-Setup erforderlich ist.
Sie lernen, wie Sie ein Manifest schreiben, das folgende Arten von Ressourcendeklarationen verwendet:
-
exec: Zum Ausführen von Befehlen wie
apt-get -
package: Zum Installieren von Paketen über apt
-
service: Um sicherzustellen, dass ein Dienst ausgeführt wird
-
file: Um sicherzustellen, dass bestimmte Dateien vorhanden sind
Manifest erstellen
Erstellen Sie auf einem neuen VPS vonlamp-1ein neues Manifest:
sudo vi /etc/puppet/manifests/lamp.ppFügen Sie die folgenden Zeilen hinzu, um die Ressourcen zu deklarieren, von denen wir gerade festgestellt haben, dass sie gewünscht werden. In den Inline-Kommentaren sind die einzelnen Ressourcendeklarationen aufgeführt:
# execute 'apt-get update'
exec { 'apt-update': # exec resource named 'apt-update'
command => '/usr/bin/apt-get update' # command this resource will run
}
# install apache2 package
package { 'apache2':
require => Exec['apt-update'], # require 'apt-update' before installing
ensure => installed,
}
# ensure apache2 service is running
service { 'apache2':
ensure => running,
}
# install mysql-server package
package { 'mysql-server':
require => Exec['apt-update'], # require 'apt-update' before installing
ensure => installed,
}
# ensure mysql service is running
service { 'mysql':
ensure => running,
}
# install php5 package
package { 'php5':
require => Exec['apt-update'], # require 'apt-update' before installing
ensure => installed,
}
# ensure info.php file exists
file { '/var/www/html/info.php':
ensure => file,
content => '', # phpinfo code
require => Package['apache2'], # require 'apache2' package before creating
}Speichern und schließen.
Manifest anwenden
Jetzt möchten Sie den Befehlpuppet apply verwenden, um das Manifest auszuführen. Führen Sie auflamp-1 Folgendes aus:
sudo puppet apply --testEs werden viele Ausgabezeilen angezeigt, die zeigen, wie sich der Status Ihres Servers ändert, um mit den Ressourcendeklarationen in Ihrem Manifest übereinzustimmen. Wenn keine Fehler aufgetreten sind, sollten Sie in der Lage sein, die öffentliche IP-Adresse (oder den Domain-Namen, falls Sie dies eingerichtet haben) zu besuchen und die PHP-Infoseite aufzurufen, die angibt, dass Apache und PHP funktionieren. Sie können auch überprüfen, ob MySQL auf Ihrem Server installiert wurde (es wurde nicht gesichert, aber wir werden uns vorerst keine Sorgen machen). Glückwunsch! Sie richten mit Puppet einen LAMP-Stapel ein.
Dieses spezielle Setup ist nicht besonders aufregend, da wir unser Agent / Master-Setup nicht ausgenutzt haben. Das Manifest ist derzeit nicht für andere Agentenknoten verfügbar, und Puppet überprüft nicht kontinuierlich (alle 30 Minuten), ob sich unser Server in dem Status befindet, den das Manifest beschreibt.
Jetzt möchten wir das Manifest, das wir gerade entwickelt haben, in ein Modul umwandeln, damit es von Ihren anderen Puppet-Knoten verwendet werden kann.
Beispiel 2: Installieren Sie LAMP, indem Sie ein neues Modul erstellen
Erstellen wir nun ein Basismodul, das auf dem in Beispiel 1 entwickelten LAMP-Manifest basiert. Wir werden dies diesmal auf dem Knoten von Puppetmastertun. Um ein Modul zu erstellen, müssen Sie ein Verzeichnis (dessen Name mit Ihrem Modulnamen übereinstimmt) immodules-Verzeichnis von Puppet erstellen. Es muss ein Verzeichnis mit dem Namenmanifests enthalten, und dieses Verzeichnis mussinit.ppenthalten. s Datei. Die Dateiinit.ppdarf nur eine Puppet-Klasse enthalten, die dem Modulnamen entspricht.
Modul erstellen
Erstellen Sie auf der Puppetmaster die Verzeichnisstruktur für ein Modul mit dem Namenlamp:
cd /etc/puppet/modules
sudo mkdir -p lamp/manifestsErstellen und bearbeiten Sie nun dieinit.pp-Datei Ihres Moduls:
sudo vi lamp/manifests/init.ppFügen Sie in dieser Datei einen Block für eine Klasse mit dem Namen "lamp" hinzu, indem Sie die folgenden Zeilen hinzufügen:
class lamp {
}Kopieren Sie den Inhalt des zuvor erstellten LAMP-Manifests (oder kopieren Sie ihn aus Beispiel 1 oben) und fügen Sie ihn in den Klassenblocklampein. In dieser Datei haben Sie eine Klassendefinition für eine "Lampen" -Klasse erstellt. Der Code innerhalb der Klasse wird zu diesem Zeitpunkt nicht ausgewertet, kann jedoch deklariert werden. Darüber hinaus können andere Manifeste auf diese Klasse als Modul zugreifen, da sie den Puppet-Konventionen zum Definieren eines Moduls entspricht.
Speichern und schließen.
Verwenden Sie das Modul im Hauptmanifest
Nachdem wir ein grundlegendes Lampenmodul eingerichtet haben, konfigurieren wir unser Hauptmanifest so, dass es zum Installieren eines LAMP-Stacks auflamp-1 verwendet wird.
Bearbeiten Sie auf der Puppemasterdas Hauptmanifest:
sudo vi /etc/puppet/manifests/site.ppAngenommen, die Datei ist leer, fügen Sie die folgendennode-Blöcke hinzu (ersetzen Sie "lamp-1" durch den Hostnamen des Puppet-Agenten, auf dem Sie LAMP installieren möchten):
node default { }
node 'lamp-1' {
}In einem Knotenblock können Sie Puppet-Code angeben, der nur für bestimmte Agentenknoten gilt. Der Knotendefaultgilt für jeden Agentenknoten, für den kein Knotenblock angegeben ist. Wir lassen ihn leer. Der Knotenblocklamp-1 gilt für den Puppenagentenknotenlamp-1.
Fügen Sie im Knotenblocklamp-1 den folgenden Code hinzu, um das soeben erstellte Modul „Lampe“ zu verwenden:
include lampNun speichern und beenden.
Wenn Ihrlamp-1 Puppet Agent-Knoten das nächste Mal seine Konfiguration vom Master abruft, wertet er das Hauptmanifest aus und wendet das Modul an, das ein LAMP-Stack-Setup angibt. Wenn Sie es sofort ausprobieren möchten, führen Sie den folgenden Befehl auf dem Agentenknoten vonlamp-1aus:
sudo puppet agent --testSobald dies abgeschlossen ist, werden Sie sehen, dass ein grundlegender LAMP-Stapel eingerichtet ist, genau wie in Beispiel 1. Um zu überprüfen, ob Apache und PHP funktionieren, rufen Sie die öffentliche IP-Adresse vonlamp-1in einem Webbrowser auf:
http://lamp_1_public_IP/info.phpSie sollten die Informationsseite für Ihre PHP-Installation sehen.
Beachten Sie, dass Sie das von Ihnen erstellte Lampenmodul wiederverwenden können, indem Sie es in anderen Knotenblöcken deklarieren. Die Verwendung von Modulen ist die beste Möglichkeit, die Wiederverwendung von Puppet-Code zu fördern, und sie ist nützlich, um Ihren Code auf logische Weise zu organisieren.
Jetzt zeigen wir Ihnen, wie Sie mit bereits vorhandenen Modulen einen ähnlichen Aufbau erzielen.
Beispiel 3: Installieren Sie LAMP mit bereits vorhandenen Modulen
Beithe Puppet Forge gibt es ein Repository öffentlich verfügbarer Module, die hilfreich sein können, wenn Sie versuchen, Ihre eigene Infrastruktur zu entwickeln. Die Puppet Forge-Module können mit dem integrierten Befehlpuppet modulechnell installiert werden. Zufällig sind hier Module zur Installation und Wartung von Apache und MySQL verfügbar. Wir werden zeigen, wie sie uns beim Einrichten unseres LAMP-Stacks helfen können.
Installieren Sie Apache- und MySQL-Module
Installieren Sie auf Ihrer Puppetmaster das Modulpuppetlabs-apache:
sudo puppet module install puppetlabs-apacheSie sehen die folgende Ausgabe, die die korrekt installierten Module anzeigt:
Notice: Preparing to install into /etc/puppetlabs/puppet/modules ...
Notice: Downloading from https://forgeapi.puppetlabs.com ...
Notice: Installing -- do not interrupt ...
/etc/puppet/modules
└─┬ puppetlabs-apache (v1.0.1)
├── puppetlabs-concat (v1.0.0) [/etc/puppet/modules]
└── puppetlabs-stdlib (v3.2.0) [/etc/puppet/modules]Installieren Sie außerdem das Modulpuppetlabs-mysql:
sudo puppet module install puppetlabs-mysqlJetzt stehen die Moduleapache undmysql zur Verfügung!
Bearbeiten Sie das Hauptmanifest
Bearbeiten wir nun unser Hauptmanifest, sodass es die neuen Module verwendet, um unseren LAMP-Stack zu installieren.
Bearbeiten Sie auf der Puppemasterdas Hauptmanifest:
sudo vi /etc/puppet/manifests/site.ppAngenommen, die Datei ist leer, fügen Sie die folgenden Knotenblöcke hinzu (wenn Sie Beispiel 2 gefolgt sind, löschen Sie einfach den Inhalt des Knotenblockslamp-1):
node default { }
node 'lamp-1' {
}Verwenden Sie im Knotenblocklamp-1 eine ressourcenähnliche Klassendeklaration, um das Modulapache zu verwenden (die Inline-Kommentare erläutern jede Zeile):
class { 'apache': # use the "apache" module
default_vhost => false, # don't use the default vhost
default_mods => false, # don't load default mods
mpm_module => 'prefork', # use the "prefork" mpm_module
}
include apache::mod::php # include mod php
apache::vhost { 'example.com': # create a vhost called "example.com"
port => '80', # use port 80
docroot => '/var/www/html', # set the docroot to the /var/www/html
}Dem Modulapache können Parameter übergeben werden, die das Standardverhalten des Moduls überschreiben. Wir übergeben einige grundlegende Einstellungen, die den vom Modul erstellten virtuellen Standardhost deaktivieren, und stellen sicher, dass wir einen virtuellen Host erstellen, der PHP verwenden kann. Eine vollständige Dokumentation des PuppetLabs-Apache-Moduls finden Sie inreadme.
Die Verwendung des MySQL-Moduls ähnelt der Verwendung des Apache-Moduls. Wir werden es einfach halten, da wir die Datenbank zu diesem Zeitpunkt nicht tatsächlich verwenden. Fügen Sie die folgenden Zeilen innerhalb des Knotenblocks hinzu:
class { 'mysql::server':
root_password => 'password',
}Wie das Apache-Modul kann das MySQL-Modul durch Übergabe von Parametern (full documentation here konfiguriert werden.
Fügen wir nun die Dateiressource hinzu, die sicherstellt, dass info.php an den richtigen Speicherort kopiert wird. Dieses Mal verwenden wir den Parametersource, um eine zu kopierende Datei anzugeben. Fügen Sie die folgenden Zeilen innerhalb des Knotenblocks hinzu:
file { 'info.php': # file resource name
path => '/var/www/html/info.php', # destination path
ensure => file,
require => Class['apache'], # require apache class be used
source => 'puppet:///modules/apache/info.php', # specify location of file to be copied
}Diese Dateiressourcendeklaration unterscheidet sich geringfügig von der vorherigen. Der Hauptunterschied besteht darin, dass wir den Parametersource anstelle des Parameterscontent angeben. Source weist die Puppe an, eine Datei zu kopieren, anstatt einfach den Inhalt der Datei anzugeben. Die angegebene Quellepuppet:///modules/apache/info.php wird von Puppet in/etc/puppet/modules/apache/files/info.php interpretiert. Daher müssen wir die Quelldatei erstellen, damit diese Ressourcendeklaration ordnungsgemäß funktioniert.
Speichern und beenden Siesite.pp.
Erstellen Sie dieinfo.php-Datei mit dem folgenden Befehl:
sudo sh -c 'echo "" > /etc/puppet/modules/apache/files/info.php'Wenn Ihrlamp-1 Puppet Agent-Knoten das nächste Mal seine Konfiguration vom Master abruft, wertet er das Hauptmanifest aus und wendet das Modul an, das ein LAMP-Stack-Setup angibt. Wenn Sie es sofort ausprobieren möchten, führen Sie den folgenden Befehl auf dem Agentenknoten vonlamp-1aus:
sudo puppet agent --testSobald dies abgeschlossen ist, werden Sie sehen, dass ein grundlegender LAMP-Stapel eingerichtet ist, genau wie in Beispiel 1. Um zu überprüfen, ob Apache und PHP funktionieren, rufen Sie die öffentliche IP-Adresse vonlamp-1in einem Webbrowser auf:
http://lamp_1_public_IP/info.phpSie sollten die Informationsseite für Ihre PHP-Installation sehen.
Fazit
Herzliche Glückwünsche! Sie haben mit Puppet einen Ubuntu 14.04 LAMP-Stack eingerichtet.
Nachdem Sie mit den Grundlagen des Puppet-Codes vertraut sind und grundlegende Manifeste und Module schreiben können, sollten Sie versuchen, mit Puppet andere Aspekte Ihrer Umgebung zu konfigurieren.
Ein guter Anfang ist, Puppet zu verwenden, um Ihre Systembenutzer und Ihre Anwendungskonfigurationsdateien zu verwalten. Denken Sie daran, dass Sie, wenn Sie Puppet zum Verwalten von Ressourcen verwenden, Änderungen an diesen bestimmten Ressourcen auf Ihrem Puppet-Masterserver vornehmen müssen. Andernfalls werden sie überschrieben, wenn Ihre Agentenknoten das nächste Mal ihre periodische Katalogabrufanforderung ausführen.
Viel Glück!