Einrichten einer masterlosen Puppenumgebung unter Ubuntu 14.04

Einführung

In der modernen Welt des Cloud Computing ist das Konfigurationsmanagement ein entscheidender Schritt. Mit Configuration Management Tools können Sie Konfigurationen zuverlässig auf Ihren Servern bereitstellen. Eines der ausgereifteren Konfigurationsmanagement-Tools in diesem Bereich ist Puppet.

In einer typischen Puppet-Umgebung schreibt ein Benutzer Puppet-Module auf seine Workstation und schiebt die Module an einen Versionskontrollserver (z. Git) und zieht diese Module dann zu einem Puppet-Master herunter. Ein Server, auf dem der Puppet-Client ausgeführt wird, stellt regelmäßig eine Verbindung zum Puppet-Master her, um festzustellen, ob sich etwas geändert hat, und wendet die Änderungen an, falls dies der Fall ist.

Dieses Szenario funktioniert einwandfrei, bis Sie anfangen müssen, die Anzahl der Server zu erhöhen, die einchecken, oder die Module ziemlich komplex werden. Zu diesem Zeitpunkt haben Sie zwei Möglichkeiten: Gruppieren Sie Ihren Puppet Master, um die Last zu bewältigen (was wahrscheinlich erfordert, dass Sie die kommerzielle Version von Puppet kaufen), oder lassen Sie den Puppet Master einfach ganz fallen. Dieser Artikel befasst sich mit der zweiten Option.

Bei einem masterlosen Puppet-Setup muss eine Kopie aller Puppet-Module über Git auf jeden Knoten kopiert werden, und Puppet muss die Änderungen dann lokal anwenden. Der Nachteil bei dieser Methode besteht darin, dass jeder Server alle Module herunterlädt und dann das Relevante anwendet. Daher ist dies nicht die beste Wahl für z. Setups mit vertraulichen Informationen. Das Ausführen ohne Puppet Master bietet Ihnen jedoch viel Flexibilität und funktioniert hervorragend, ohne dass Sie Ihre Infrastruktur skalieren müssen.

Voraussetzungen

Wenn Sie Puppet noch nicht kennen, können Sie hier eine Pause einlegen, um diesen Artikel über Puppet zu lesen als erstes, da dieses Tutorial ein funktionierendes Wissen über das Tool voraussetzt. Wenn Sie neu bei Git sind, können Sie auch this Introduction to Git series lesen.

In diesem Tutorial arbeiten wir mit zwei Droplets: einem, der als Git-Server ausgeführt wird, und dem anderen, auf den wir Änderungen über Puppet anwenden. Wir verweisen auf die IP-Adressen dieser Droplets mit "+ your_git_server_ip " bzw. " your_puppet_server_ip +".

Um diesem Tutorial zu folgen, benötigen Sie:

Ein Ubuntu 14.04-Droplet mit einem sudo non-root user und SSH keys added.
Ein weiteres Ubuntu 14.04-Dropet mit hinzugefügten SSH-Schlüsseln und Git Labs.

Die einfachste Möglichkeit, Git Labs einzurichten, besteht darin, das Ein-Klick-Image zu verwenden: Klicken Sie auf der Droplet-Erstellungsseite unter * Image auswählen * auf die Registerkarte * Anwendungen * und dann auf * GitLab 7.10.0 CE am 14.04 *. Sie können auch this tutorial folgen, um Git Labs einzurichten manuell.

Schritt 1 - Ein Git-Repository erstellen

Der erste Schritt besteht darin, ein Repository zu erstellen, in dem alle unsere Puppet-Module und -Manifeste gespeichert werden.

Öffnen Sie zunächst die Git Labs-Benutzeroberfläche, indem Sie in Ihrem bevorzugten Browser zu "+ http: // +" wechseln. Erstellen Sie ein Konto, indem Sie die Details rechts unter * Neuer Benutzer? Erstellen Sie ein Konto * und klicken Sie auf die grüne Schaltfläche * Anmelden *. Sie erhalten eine E-Mail zur Kontoaktivierung. Nach der Aktivierung Ihres Kontos können Sie sich auf der Hauptseite anmelden.

Klicken Sie auf der Hauptseite auf die grüne Schaltfläche * + Neues Projekt *. Geben Sie "Marionette" als * Projektpfad * ein und klicken Sie auf * Projekt erstellen *. Geben Sie "Marionette" in das Feld * Projektpfad * ein und wählen Sie * Öffentlich * als * Sichtbarkeitsstufe *. Klicken Sie dann auf die grüne Schaltfläche * Projekt erstellen *.

Stellen Sie sicher, dass Sie die SSH-URL kopieren, die im oberen Bereich des Projektbildschirms angezeigt wird, da wir sie in einem späteren Schritt benötigen. Es sieht ungefähr so aus wie "+ git @: / puppet.git +".

Schritt 2 - Hinzufügen eines SSH-Schlüssels zu Git Labs

In diesem Schritt erstellen wir einen SSH-Schlüssel auf dem Puppet-Server und fügen diesen Schlüssel dem Git Labs-Server hinzu.

Melden Sie sich beim Puppet-Server als * root * an. (Da sich Puppets Dateien im Besitz von root befinden, benötigen wir Rechte, um das anfängliche Git-Repo im Puppet-Ordner einzurichten.)

Erstellen Sie einen SSH-Schlüssel für den Root-Benutzer. Stellen Sie sicher, dass Sie keine Passphrase eingeben, da dieser Schlüssel von Skripten und nicht von einem Benutzer verwendet wird.

ssh-keygen -t rsa

Zeigen Sie anschließend Ihren öffentlichen Schlüssel mit dem folgenden Befehl an.

cat ~/.ssh/id_rsa.pub

Kopieren Sie diesen Schlüssel. Es sieht ungefähr so aus wie + ssh-rsa long_alphanumeric_string root @ +.

Klicken Sie nun auf Ihrer Git Labs-Dashboard-Seite auf das Symbol * Profileinstellungen * in der oberen Leiste, die zweite von rechts. Klicken Sie im linken Menü auf * SSH-Schlüssel * und dann auf die grüne Schaltfläche * Einen SSH-Schlüssel hinzufügen *. Fügen Sie im Feld * Titel * eine Beschreibung des Schlüssels hinzu (z. B. "Root Puppet Key") und fügen Sie Ihren öffentlichen Schlüssel in das Feld * Schlüssel * ein. Klicken Sie abschließend auf * Schlüssel hinzufügen *.

Schritt 3 - Puppet und Git installieren

In diesem Schritt installieren wir Puppet und Git.

Laden Sie auf dem Puppet-Server zuerst das Puppet-Paket für Ubuntu 14.04 herunter.

wget http://apt.puppetlabs.com/puppetlabs-release-trusty.deb

Installieren Sie das Paket.

dpkg -i /tmp/puppetlabs-release-trusty.deb

Aktualisieren Sie die Paketliste Ihres Systems.

apt-get update

Zum Schluss installieren Sie Puppet und git.

apt-get install puppet git-core

Zu diesem Zeitpunkt sollten Sie Ihre Git-Umgebung konfigurieren, indem Sie den Anweisungen unter https://www.digitalocean.com/community/tutorials/how-to-install-git-on-ubuntu-14-04#how-to-set folgen -up-git [dieses Tutorial].

Schritt 4 - Drücken der anfänglichen Puppenkonfiguration

Nachdem Puppet und Git installiert sind, können wir unseren ersten Push für unser Puppet-Repository ausführen.

Wechseln Sie zunächst in das Verzeichnis "+ / etc / puppet +", in dem sich die Konfigurationsdateien befinden.

cd /etc/puppet

Initialisieren Sie hier ein Git-Repository.

git init

Fügen Sie alles im aktuellen Verzeichnis hinzu.

git add .

Übernehmen Sie diese Änderungen mit einem beschreibenden Kommentar.

git commit -m ""

Fügen Sie das Git-Projekt, das wir zuvor als Ursprung erstellt haben, mit der SSH-URL hinzu, die Sie in Schritt 1 kopiert haben.

git remote add origin git@:/puppet.git

Und schließlich die Änderungen drücken.

git push -u origin master

Schritt 5 - Aufräumen der Puppenkonfiguration

Jetzt, wo Puppet installiert ist, können wir alles zusammensetzen. Zu diesem Zeitpunkt können Sie sich als Root abmelden und sich stattdessen als der Benutzer ohne Rootberechtigung anmelden, den Sie unter den Voraussetzungen erstellt haben. Es ist keine gute Praxis, als Root-Benutzer zu arbeiten, es sei denn, dies ist unbedingt erforderlich.

Um die Grundlage zu schaffen, müssen wir einige Änderungen vornehmen. Zuerst werden wir die Datei + / etc / puppet / puppet.conf bereinigen. Bearbeiten Sie mit Ihrem bevorzugten Editor (vim, nano usw.) + / etc / puppet / puppet.conf + mit den folgenden Änderungen.

Nehmen Sie zunächst einige Änderungen an der Datei "+ /etc/puppet/puppet.conf" für Ihr spezielles Setup vor. Öffnen Sie die Datei mit nano oder Ihrem bevorzugten Texteditor.

sudo nano /etc/puppet/puppet.conf

Die Datei sieht folgendermaßen aus:

Original /etc/puppet/puppet.conf

[main]
logdir=/var/log/puppet
vardir=/var/lib/puppet
ssldir=/var/lib/puppet/ssl
rundir=/var/run/puppet
factpath=$vardir/lib/facter
templatedir=$confdir/templates

[master]
# These are needed when the puppetmaster is run by passenger
# and can safely be removed if webrick is used.
ssl_client_header = SSL_CLIENT_S_DN
ssl_client_verify_header = SSL_CLIENT_VERIFY

Entfernen Sie zuerst alles aus der Zeile "+ [master] " unten, da wir keinen Puppet-Master ausführen. Löschen Sie auch die letzte Zeile im Abschnitt " [main] ", die mit " templatedir " beginnt, da dies veraltet ist. Ändern Sie abschließend die Zeile, die " factpath = $ vardir / lib / facter " lautet, in " factpath = $ confdir / facter ". " $ confdir " ist äquivalent zu " / etc / puppet / +", d.h. unser Puppenhaus.

Hier ist, wie Ihre + puppet.conf aussehen sollte, wenn Sie mit den obigen Änderungen fertig sind.

Geändert /etc/puppet/puppet.conf

[main]
logdir=/var/log/puppet
vardir=/var/lib/puppet
ssldir=/var/lib/puppet/ssl
rundir=/var/run/puppet
factpath=$confdir/facter

Schritt 6 - Hinzufügen eines Puppenmoduls

Jetzt ist Puppet eingerichtet, aber es macht keine Arbeit. Die Funktionsweise von Puppet besteht darin, dass Sie sich Dateien ansehen, die als Manifeste bezeichnet werden und die definieren, was es tun soll. In diesem Schritt erstellen wir ein nützliches Modul, das Puppet ausführen kann.

Unser erstes Modul, das wir Cron-Puppet nennen, wird Puppet über Git bereitstellen. Es wird ein Git-Hook installiert, mit dem Puppet nach einer erfolgreichen Zusammenführung ausgeführt wird (z. B. git pull), und es wird ein Cron-Job installiert, der alle 30 Minuten ein + git pull + ausführt.

Wechseln Sie zunächst in das Puppet-Modulverzeichnis.

cd /etc/puppet/modules

Als nächstes erstellen Sie ein Cron-Puppet-Verzeichnis mit Manifesten und Dateien.

sudo mkdir -p cron-puppet/manifests cron-puppet/files

Erstellen und öffnen Sie eine Datei mit dem Namen "+ init.pp " im Verzeichnis " manifests +".

sudo nano cron-puppet/manifests/init.pp

Kopieren Sie den folgenden Code in + init.pp +. Dies ist es, was Puppet anweist, jede halbe Stunde von Git zu ziehen.

init.pp

class cron-puppet {
   file { 'post-hook':
       ensure  => file,
       path    => '/etc/puppet/.git/hooks/post-merge',
       source  => 'puppet:///modules/cron-puppet/post-merge',
       mode    => 0755,
       owner   => root,
       group   => root,
   }
   cron { 'puppet-apply':
       ensure  => present,
       command => "cd /etc/puppet ; /usr/bin/git pull",
       user    => root,
       minute  => '*/30',
       require => File['post-hook'],
   }
}

Speichern und schließen Sie die Datei und öffnen Sie dann eine weitere Datei mit dem Namen "+ post merger" im Verzeichnis "+ files in".

sudo nano cron-puppet/files/post-merge

Kopieren Sie das folgende Bash-Skript in + Post-Merge +. Dieses Bash-Skript wird nach einer erfolgreichen Git-Zusammenführung ausgeführt und protokolliert das Ergebnis der Ausführung.

Nach dem Zusammenführen

#!/bin/bash -e
## Run Puppet locally using puppet apply
/usr/bin/puppet apply /etc/puppet/manifests/site.pp

## Log status of the Puppet run
if [ $? -eq 0 ]
then
   /usr/bin/logger -i "Puppet has run successfully" -t "puppet-run"
   exit 0
else
   /usr/bin/logger -i "Puppet has ran into an error, please run Puppet manually" -t "puppet-run"
   exit 1
fi

Speichern und schließen Sie diese Datei

Schließlich müssen wir Puppet anweisen, dieses Modul auszuführen, indem wir ein globales Manifest erstellen, das kanonisch unter + / etc / puppet / manifests / site.pp + zu finden ist.

sudo nano /etc/puppet/manifests/site.pp

Fügen Sie folgendes in + site.pp + ein. Dadurch wird eine Knotenklassifikation mit dem Namen "Standard" erstellt. Was auch immer im 'Standard'-Knoten enthalten ist, wird auf jedem Server ausgeführt. Hier teilen wir ihm mit, dass er unser + cron-puppet + Modul ausführen soll.

site.pp

node default {
   include cron-puppet
}

Speichern und schließen Sie die Datei. Lassen Sie uns nun sicherstellen, dass unser Modul funktioniert, indem Sie es ausführen.

sudo puppet apply /etc/puppet/manifests/site.pp

Nach einem erfolgreichen Lauf sollte eine Ausgabe mit einer solchen Zeile enden.

...

Notice: Finished catalog run in 0.18 seconds

Lassen Sie uns zum Schluss unsere Änderungen in das Git-Repository übertragen. Melden Sie sich zunächst als Root an, da dies der Benutzer mit SSH-Schlüsselzugriff auf das Repository ist.

Wechseln Sie anschließend in das Verzeichnis "+ / etc / puppet +".

cd /etc/puppet

Fügen Sie dem Commit alles in diesem Verzeichnis hinzu.

git add .

Übernehmen Sie die Änderungen mit einer beschreibenden Meldung.

git commit -m ""

Schließlich drücken Sie die Änderungen.

git push -u origin master

Fazit

Um weitere Server hinzuzufügen, führen Sie einfach Schritt 3 oben aus, um Puppet und Git auf dem neuen Server zu installieren. Klonen Sie dann das Git-Repository nach + / etc / puppet + und wenden Sie das Manifest + site.pp + an.

Sie können diese Installation sogar automatisieren, indem Sie user data verwenden, wenn Sie ein Droplet erstellen. Stellen Sie sicher, dass Sie beim Erstellen des Droplets einen SSH-Schlüssel verwenden und diesen SSH-Schlüssel zu Ihrem GitLab-Server hinzugefügt haben. Aktivieren Sie dann einfach das Kontrollkästchen * Benutzerdaten aktivieren * im Droplet-Erstellungsbildschirm und geben Sie das folgende Bash-Skript ein, wobei Sie die rot hervorgehobenen Variablen durch Ihre eigenen ersetzen.

#!/bin/bash -e

## Install Git and Puppet
wget -O /tmp/puppetlabs.deb http://apt.puppetlabs.com/puppetlabs-release-`lsb_release -cs`.deb
dpkg -i /tmp/puppetlabs.deb
apt-get update
apt-get -y install git-core puppet

# Clone the 'puppet' repo
cd /etc
mv puppet/ puppet-bak
git clone http:////puppet.git /etc/puppet

# Run Puppet initially to set up the auto-deploy mechanism
puppet apply /etc/puppet/manifests/site.pp

Das ist alles! Sie haben jetzt ein masterloses Puppet-System und können eine beliebige Anzahl zusätzlicher Server hochfahren, ohne sich überhaupt bei ihnen anmelden zu müssen.

TOC