Puppet: Informationen des Nodes mit facter auslesen

In heterogenen Setups ist es wichtig das sich die Module und Klassen den nodespezifischen Eigenheiten anpassen. Dafuer koennen in Puppet Informationen aus facter verwendet werden.

Facter is an independent, cross-platform Ruby library designed to gather information on all the nodes you will be managing with Puppet. It is available on all platforms that Puppet is available.

Facter ist auch ein eigenstaendiges Tool. Nach dem Aufruf werden die zur Verfuegung stehenden Informationen ausgegeben.

Ein Anwendungsbeispiel ist mit einem Modul sicherzustellen, dass SSH installiert und der SSH Serverdienst auch laeuft. Auf Debian basierten Systemen heisst der Dienst ’ssh‘, waerend auf RedHat basierten Systemen der Dienst ’sshd‘ heisst. In einem Puppet Modul laesst sich das mit Informationen aus facter wie folgt abbilden:

class ssh_server {
  case $::osfamily {
    Debian: {
      $serviceName = 'ssh'
    }
    RedHat: {
      $serviceName = 'sshd'
    }
  }
 
  service { $serviceName:
    ensure => 'running',
  }

Aber nicht nur in den manifest Dateien kann man auf die Informationen aus facter zurueckgreifen, auch in den Templates stehen diese zur Verfuegung. Eine sinnvolle Modifikation des Templates jail.local.erb das ich in dem fail2ban Modul gezeigt habe ist, die Emails nicht an fail2ban@localhost sondern an fail2ban@FQDN zu verschicken. Dafuer muss die folgende Zeile geaendert werden:

  • alt:
    destemail = fail2ban@localhost
  • neu:
    destemail = fail2ban@<%= fqdn %>

Puppet: Virtuelle Ressourcen fuer Gruppen und ein Beispiel aus der Praxis

Ich habe gerade ueber virtuelle Ressourcen fuer Benutzer und public SSH-Keys geschrieben. Nach dem gleichen Schema kann man natuerlich auch virtuelle Ressourcen fuer Gruppen erzeugen. Wofuer man das ganze in der Praxis brauchen kann moechte ich an dem folgenden Beispiel erklaeren.

Das ganze basiert auf dem Beispielmodul users aus dem Beitrag Puppet: Virtuelle Ressourcen fuer Benutzer und SSH-Keys. Dort habe ich naemlich fuer den Benutzer mmuster die Gruppe wheel konfiguriert.

Mit Puppet kann ich nun in einem eigenen Modul sehr simpel sicherstellen, dass diese Gruppe auch existiert. Mein Modul groups sieht wie folgt aus:

└── manifests
    ├── init.pp
    ├── virtual.pp
    └── wheel.pp

Und auch der Aufbau der drei Dateien sind genau wie die in dem users Modul, nur viel einfacher:

  • init.pp
    class groups () {
      include groups::virtual
    }
  • virtual.pp
    class groups::virtual {
      @group { 'wheel':
        ensure => 'present',
        }
    }
  • wheel.pp
    class groups::wheel inherits groups::virtual {
      realize(
        Group['wheel']
      )
    }

Um sicherzustellen, dass die Gruppe wheel auch wirklich existiert, erweitere ich nun die Klasse mmuster.pp aus dem Beispiel des anderen Beitrags um einen include fuer die Gruppe wheel. Das ganze sieht dann wie folgt aus:

class users::mmuster inherits users::virtual {
 
  include groups::wheel
 
  realize(
    User['mmuster'],
    Ssh_authorized_key['mmuster-privat']
  )
}

Ich mache das ganze natuerlich nicht einfach nur um den Benutzer in irgendeine Gruppe zu packen, sondern die Gruppe soll auch spezielle Berechtigungen erhalten: root Rechte erlangen ohne Passworteingabe. Dieses realisiere ich ueber sudo. Dafuer habe ich ebenfalls ein eigenes Modul „sudoers“ und darin wiederum die Klasse „wheel“. Diese sieht wie folgt aus:

class sudoers::wheel {
 
  include groups::wheel
 
  file { '/etc/sudoers.d/60_wheel':
    ensure => 'present',
    source => 'puppet:///modules/sudoers/etc/sudoers.d/60_wheel',
    owner  => 'root',
    group  => 'root',
    mode   => '0440'
  }
}

Der zweite Ort an dem die Gruppe wheel konfiguriert ist. Spaetestens jetzt wuerde es zu Problemen kommen, wenn die Klasse wheel aus dem sudoers Modul UND der Nutzer mmuster zusammen auf einem Node konfiguriert sind. Mit den virtuellen Ressourcen hingegen klappt es.

Ach so, die /etc/sudoers.d/60_wheel sieht uebrigens so aus:

#############################################################################
#                                                                           #
# !!! This file is managed by puppet, all manual changes will be lost !!!   #
#                                                                           #
#############################################################################
 
#
# Members of the wheel group may gain root privileges without password
#
 
%wheel          ALL = (ALL) NOPASSWD: ALL

Puppet: Ein Modul mit mehreren Klassen

Bisher hab ich immer nur pro Modul eine Klasse definiert. Es existiert an dieser Stelle aber keine Beschraenkung. In der init.pp wird eine Klasse definiert die den Modulnamen tragen muss. Daneben koennen aber weitere .pp Dateien liegen die ebenfalls Klassen implementieren.

Ich persoenlich habe auf verschiedenen Servern verschiedene Dateien unter /etc/cron.d/ abgelegt die ich auch in puppet ueberfuehrt habe. Da ich nicht alle Cronjobs auf allen Nodes deployen (und auch ausfuehren) moechte, gleichzeitig aber nicht fuer jedes Datei ein eigenes Modul definieren will, habe ich ein Modul „cronjobs“ erzeugt mit verschiedenen Klassen. Hier eine beispielhafte Struktur:

├── files
│   └── etc
│       └── cron.d
│           └── foo
└── manifests
    ├── foo.pp
    └── init.pp

Die init.pp hat fast keinen Inhalt:

# class that contains several cronjobs on different hosts
 
class cronjobs () {
 
}

Die Datei foo.pp sieht wie folgt aus:

# place cron.d file for foo job
 
class cronjobs::foo {
 
  file { '/etc/cron.d/foo':
    ensure => 'file',
    owner  => 'root',
    group  => 'root',
    mode   => '0644',
    source => 'puppet:///modules/cronjobs/etc/cron.d/foo'
  }
}

Wichtig ist hier, dass die Klasse MODULNAME::KLASSE heisst. Genauso wird diese Klasse dann auch in einem Node definiert:

node 'client1.example.org' inherits default {
 
  class { 'cronjobs::foo': }
}

Haette man in dem gleichen Modul noch eine Klasse cronjobs::bar koennte man diese in einem anderen Node definieren. So kann ich in einem Modul verschiedene Cronjob Dateien haben die auf unterschiedlichen Hosts deployt werden.