Select Page

NETWAYS Blog

Puppet Hash Injection

forge-logoFolgende Ausgangssituation, wir wollen eine Konfigurationsdatei zeilenweise mit beliebigen Optionen und den zugehörigen Werten verwalten. Hierzu benutzen wir eine Defined Resource, um jeweils einen Eintrag zu konfiguration:

define config::setting(
  $option = $title,
  $value,
) {
  file_line { "config::setting::${option}":
    line => "${option} = ${value}",
    ...
}

Nun möchten wir jedoch aus einer Klasse heraus, einen einfachen Hash zur Deklaration verwenden und nicht einen Hash of Hashes.

class { 'config':
  options => { 'opt1' => 'alpha', 'opt2' => 'beta' },
}

Das Problem ist nun, dass wir aus options einen Hash der folgenden Form machen müssen, um mit create_resources, opt1 und opt2 anlegen zu können.

{ 'opt1' => { 'value' => 'alpha' },
  'opt2' => { 'value' => 'beta' },
}

Ruby bietet für Hashes eine Methode inject, die wir innerhalb eines inline_templates anwenden. Die inline_template Funktion liefert jedoch nur Strings zurück und keinen Hash. Deshalb geben wir den String in YAML zurück, den wir abschließend mit der im Module puppetlabs-stdlib enthaltenen Funktion parseyaml wieder in einen Hash der geforderten Form umwandeln.

class config(
  $options = {},
) {
  create_resources('config::setting',
    parseyaml(inline_template(
      '<%= @options.inject({}) {|h, (x,y)| h[x] = {"option" => x, "value" => y}; h}.to_yaml %>'))
  )
}
Lennart Betz
Lennart Betz
Senior Consultant

Der diplomierte Mathematiker arbeitet bei NETWAYS im Bereich Consulting und bereichert seine Kunden mit seinem Wissen zu Icinga, Nagios und anderen Open Source Administrationstools. Im Büro erleuchtet Lennart seine Kollegen mit fundierten geschichtlichen Vorträgen die seinesgleichen suchen.

Paketstation

Mit FPM stellt Jordan Sissel, der führende Kopf hinter Logstash, ein Tool zur Verfügung mit dem man sehr einfach Pakete für die gängigsten Distributionen erstellen kann.
Für Effing Package Management (=FPM) muss Ruby und ein C-Compiler vorhanden sein:

# apt-get install ruby-dev gcc
# yum install ruby-devel gcc

Danach kann die eigentliche Installation des Ruby-Moduls erfolgen:

# gem install fpm

Als Beispiel für die Erstellung von Paketen mit FPM habe ich im Folgenden LConf Standalone Web gewählt, natürlich kann dies auch auf andere Softwareprodukte abgewandelt werden.
Zuerst muss bei LConf Web das Archiv mit dem Quellcode herunter geladen und entpackt werden, danach wechselt man wie gewohnt in das extrahierte Verzeichnis. Im Anschluss wird hier der configure-Befehl ausgeführt:

# ./configure --with-user=icinga --with-group=icinga

Bis zu diesem Zeitpunkt besteht noch kein Unterschied zum üblichen Installationsvorgang, erst bei make install unterscheidet sich der Aufruf. Statt die Dateien an den dafür vorgesehenen Stellen im Dateisystem abzulegen, leitet man sie mit dem DESTDIR-Parameter um:

# make install DESTDIR=/usr/local/src/lconf-web-1.4.0_installdir

Jetzt ist die Zeit von FPM gekommen, den hier kann nun das DESTDIR-Verzeichnis als Chroot verwendet und die darin enthaltene Verzeichnisstruktur “usr/local/lconf-web” beispielsweise in ein Debian-Paket integriert werden:

# fpm -s dir -t deb -n lconf-web -v 1.4.0 --deb-use-file-permissions \
-C /usr/local/src/lconf-web-1.4.0_installdir usr/local/lconf-web

Das dabei entstandene Paket lconf-web-1.4.0_amd64.deb kann nun natürlich mit dpkg auf einem Debian basierten System installiert werden.

Markus Waldmüller
Markus Waldmüller
Head of Strategic Projects

Markus war bereits mehrere Jahre als Sysadmin in Neumarkt i.d.OPf. und Regensburg tätig. Nach Technikerschule und Selbständigkeit ist er nun Anfang 2013 bei NETWAYS als Senior Manager Services gelandet. Seit September 2023 kümmert er sich bei der NETWAYS Gruppe um strategische Projekte. Wenn er nicht gerade die Welt bereist, ist der sportbegeisterte Neumarkter mit an Sicherheit grenzender Wahrscheinlichkeit auf dem Mountainbike oder am Baggersee zu finden.

Benutzung von Git zur Environment-Verwaltung bei Puppet mit r10k

Puppet_LogoNachdem ich nun schon jahrelang mit Git im Puppetumfeld kämpfe, gibt es nun mit dem Ruby-Skript r10k eine wunderbar nützliche Ergänzung. Mit r10k wird das Deployment von Branches als dynamische Environments zum Kinderspiel. Stellt sich natürlich zuerst die Frage, was versteht man unter dynamischen Environments?
Gemeint ist das Hinzufügen bzw. Löschen von Environments zur Laufzeit. Nur wozu das Ganze? Wenn ich z.B. an einem Puppetmodul arbeite will ich es nicht nur lokal mit puppet apply testen, sondern auch mit einem Puppetmaster. Dieses vorgehen wird spätestens zum Muss, wenn ich Exported Resources verwende möchte.
Genug der reinen Worten, ein skizziertes Beispiel wird es verdeutlichen. Wir starten mit der Konfiguration von Puppet für die Verwendung dynamischer Environments, hierzu passen wir die puppet.conf auf unserem Master an.

[main]
modulepath=/etc/puppet/environments/$environment/modules

71px-Git-logo.svgDas Verzeichnis /etc/puppet/environments muss vorhanden sein, die untergeordneten werden von r10k automatisch nach Bedarf angelegt. Nun benötigen wir ein GIT-Repository, aus dem r10k jeden Branch in ein Environment umwandelt. Das r10k-site.git genannte Repository erzeugen wir als Remote-Repository auf unserem Puppetmaster.

# git init --bare r10k-site.git

Bevor wir dieses mit Inhalt befüllen, ist r10k noch zu installieren

# gem install r10k

und zu konfigurieren. Letzteres ist in der Datei /etc/r10k.yaml vorzunehmen.

:cachedir: /var/cache/r10k
:sources:
  puppet:
    remote: "/var/repositories/r10k-site.git"
    basedir: /etc/puppet/environments
:purgedirs:
  - /etc/puppet/environments

Neben einem Cache-Verzeichnis, wird hier mit remote das Remote-Repository angegeben und das Verzeichnis, in das wir jeden Branch als Environment bauen lassen möchten. Mit purgedirs sorgen wir dafür, dass gelöschte Branche auch als Environment wieder entfernt werden.
Nun wählen wir uns einen Ort für ein git clone von r10k-site.git aus. In diesem legen wir dann die gewünschten Branches an, die dann zu den von uns gewünschten Environments zusammen gebaut werden. Jeder Branch muss hierbei eine Datei Puppetfile enthalten, in der wir, die in diesem Environment einzubauenden Module angeben.

forge "http://forge.puppetlabs.com"
mod "puppetlabs/stdlib", "3.2.2"
mod "tomcat",
  :git => "git@github.com:lbetz/puppet-tomcat.git",
  :ref => "0.3.2"

Ruft man nun das Ruby-Skript auf unserem Host auf dem r10k konfiguriert ist, z.B. mit

# r10k deploy environment -p

auf, werden alle Branches mit den in Puppetfile angegebenen Modulen als eigenes Environment nach basedir geschrieben. Die Option -p sorgt jeweils für erforderliche Updates der Module. Ein bestimmtes Environment kann mit

# r10k deploy environment <env_name> -p

erstellt werden. Packt man diese Aufrufe in einen Git-Hook, z.B. post-update, werden die Environments bei jedem Update des Repositories automatisch aktualisiert, angelegt oder gelöscht.

Lennart Betz
Lennart Betz
Senior Consultant

Der diplomierte Mathematiker arbeitet bei NETWAYS im Bereich Consulting und bereichert seine Kunden mit seinem Wissen zu Icinga, Nagios und anderen Open Source Administrationstools. Im Büro erleuchtet Lennart seine Kollegen mit fundierten geschichtlichen Vorträgen die seinesgleichen suchen.

Puppenschnur im XML-Baum verheddert

Wer sich schon mal mit Puppet und XML-Konfigurationsdateien beschäftigt hat, weiß das dies ein schwer umzusetzendes Vorhaben in Puppet ist. Es gibt zwar eine Linse für Augeas, wer aber eine komplette XML-Datei mit Puppet verwalten möchte, wird damit schnell wahnsinnig.
Ich hatte vor einigen Wochen das Glück, mich bei einem Kunden, näher mit der Konfiguration vom Tomcat beschäftigen zu dürfen. Dabei stand ich vor dem Problem, z.B. folgende Struktur als server.xml mit Puppet erzeugen zu müssen.

<Server>
  <Service name=Catalina>
    <Engine name=Catalina>
      <Host name=...>
        ...
      </Host>
      <Host name=...>
        ...
      </Host>
    </Engine>
  </Service>
</Server>

Wobei in den Host-Sektionen natürlich auch nochmals Schachtelungen vorkommen. Mein erster Lösungsansatz war, mit XML Referenzen auf eigenständige Dateien zu verweisen, die damit eingebunden werden. Dies führt nun aber zu einem recht unübersichtlichen Datei-Tohuwabohu.
Die jetzige Lösung macht sich die Eigenschaften des Puppet concat-Moduls zu nutze. Die einzelnen Fragmente werden auf dem Puppet-Agent jeweils als separate Datei in ein temporäres Verzeichnis geschrieben, z.B. nach /var/lib/puppet/concat/_etc_tomcat_server.xml/fragments. Das Attribut order von concat::fragment dient hierbei als Prefix für den Dateiname des entsprechenden Fragments. Sind alle Fragmente geschrieben, liest ein Skript alle Dateien mittels find, sortiert lexikalisch nach Dateinamen und fügt die Fragmente abschließend mittels cat in die Zieldatei zusammen, hier /etc/tomcat/server.xml.
Schaut man sich dieses find näher an, stellt man fest, dass es nicht tiefenbeschränkt ist, d.h. es durchsucht auch weitere Unterverzeichnisse. Diese können vorab mit einer files-Resource angelegt werden und im order-Attribut mit angegeben werden.

concat { '/etc/tomcat/server.xml':
  mode => '0644',
} ->
file { '/var/lib/puppet/concat/_etc_tomcat_server.xml/50_host_A':
  ensure => directory,
}
concat::fragment { 'engine-header':
  target => '/etc/tomcat/server.xml',
  content => "\n",
  order => '40',
}
concat::fragment { 'engine-footer':
  target => '/etc/tomcat/server.xml',
  content => "\n",
  order => '60',
}
concat::fragment { 'host_A-header':
  target => '/etc/tomcat/server.xml',
  content => "\n",
  order => '50_host_A/00',
  require => File['/var/lib/puppet/concat/_etc_tomcat_server.xml/50_host_A'],
}
concat::fragment { 'host_A-footer':
  target => '/etc/tomcat/server.xml',
  content => "\n",
  order => '50_host_A/99',
  require => File['/var/lib/puppet/concat/_etc_tomcat_server.xml/50_host_A'],
}

Analog für weitere Hosts. Zusätzliche Fragmente für Host A lassen sich nun zwischen dem Header und Footer einordnen. Dies soll erstmal nur die Idee vergegenwärtigen. Ein komplexeres Anwendungsbeispiel findet sich unter https://github.com/lbetz/netways-tomcat.
Auch ist zu bedenken, das auf unterschiedlichen Hosts das temporärere concat-Verzeichnis nicht immer am selben Ort zu finden ist. Hier schaft ein selbstgeschriebener Fact Abhilfe.

# vardir.rb
Facter.add(:vardir) do
  setcode do
    Puppet[:vardir]
  end
end
Lennart Betz
Lennart Betz
Senior Consultant

Der diplomierte Mathematiker arbeitet bei NETWAYS im Bereich Consulting und bereichert seine Kunden mit seinem Wissen zu Icinga, Nagios und anderen Open Source Administrationstools. Im Büro erleuchtet Lennart seine Kollegen mit fundierten geschichtlichen Vorträgen die seinesgleichen suchen.

Ruby zaubert mit Excel und Spreadsheets

In der heutigen Arbeitswelt werden viele Daten in Spreadsheets oder Exceltabellen verwaltet.
Ein paar Tage ist es her, da galt es für mich anhand einer Exceltabelle Infos zu einem Projekt zu sammeln und mit zugehörigen Dateien in ein Verzeichnis zu verpacken.
Dabei war es Fakt die Datensätze der Tabelle auszulesen und mit den Datensätzen in der Datenbank zu vergleichen.
Bei Google stößt man dabei schnell auf “CSV Spreadsheets lesen” nur dann wird das Konvertieren und Selektieren zur schmerzlichen Angelegenheit.
Um größere Schäden zu vermeiden, gibt es schlaue Magier die immer ein Gem in dem Zylinder haben.
Dazu stelle ich euch das RubyGem “Roo” vor, dass das Verarbeiten von Excelsheets zu einem Kinderspiel macht.
Ich werde mich bei dem Beispiel nur auf den kleinsten Anwendungsfall beziehen.
Und dazu installieren wir das Gem zuerst:

$ sudo ruby gem install roo

Unser Beispiel ist eine Spreadsheet im .xlsx Format.
screenshot1

#!/usr/bin/env ruby
require 'rubygems'
require 'roo'
foo = Roo::Excelx.new("projects.xlsx")
foo.default_sheet = foo.sheets.first
2.upto(8) do |line|
  project_title = foo.cell(line,'A')
  type = foo.cell(line, 'B')
  vendor = foo.cell(line, 'C')
  target = foo.cell(line, 'D')
  puts "#{project_title}\t#{type}\t#{vendor}\t#{target}"
end
foo.to_csv("foo.csv")

Mit diesem Zehnzeiler wird für die Zeile 2 bis 4 der jeweilige Inhalt einer Spalte
in die dafür definierte Variable geschrieben.
Mit “puts” wird der Inhalt der Variable an die Ausgabe gegeben.
Bildschirmfoto 2014-05-06 um 12.20.26
Falls die Excelsheets zu lang sind um ein Ende definieren zu können kann das upto() mit weiteren
Optionen ausgeführt werden.

first_column,
last_column,
first_row and
last_row

Auf unseren Fall angepasst, schaut das so aus:

2.upto(foo.last_row) do |line|

Mit diesem Gem macht auch das Verarbeiten von großen Exceltabellen wieder einen Sinn.
Weitere Infos findet Ihr auf der Homepage von Roo
Ich kann dazu nur noch sagen “Just awesome!” oder auch “It’s a kind of magic!”
Mehr coole Tricks und Magie findet Ihr auf unserem Blog

Thilo Wening
Thilo Wening
Manager Consulting

Thilo hat bei NETWAYS mit der Ausbildung zum Fachinformatiker, Schwerpunkt Systemadministration begonnen und unterstützt nun nach erfolgreich bestandener Prüfung tatkräftig die Kollegen im Consulting. In seiner Freizeit ist er athletisch in der Senkrechten unterwegs und stählt seine Muskeln beim Bouldern. Als richtiger Profi macht er das natürlich am liebsten in der Natur und geht nur noch in Ausnahmefällen in die Kletterhalle.