Barkeeper mit Puppet automatisieren:it2ndq/barman (Teil 1)

Dies ist nicht das erste Mal, dass 2ndQuadrant sich Puppet ansieht. Gabriele Bartolini hat bereits einen zweiteiligen Artikel zur schnellen Konfiguration eines PostgreSQL-Servers über Puppet und Vagrant geschrieben, begleitet von der Veröffentlichung des im Beispiel verwendeten Codes auf GitHub (http://github.com/2ndquadrant-it/vagrant -puppet-postgresql).

In drei Teile gegliedert, ist das Ziel dieses Artikels, die Automatisierung der Einrichtung und Konfiguration von Barman zu demonstrieren, um einen PostgreSQL-Testserver zu sichern.

Dieser Artikel ist eine Aktualisierung dessen, was von Gabriele mit der Idee geschrieben wurde, zwei virtuelle Maschinen statt einer zu erstellen, einen PostgreSQL-Server und einen Barman-Server.

it2ndq/barman ist das von 2ndQuadrant Italien veröffentlichte Modul zur Verwaltung der Installation von Barman über Puppet. Das Modul hat eine GPLv3-Lizenz und ist auf GitHub unter der Adresse http://github.com/2ndquadrant-it/puppet-barman verfügbar. Das folgende Verfahren wurde für Ubuntu 14.04 Trusty Tahr geschrieben, kann aber auf ähnliche Weise auf anderen Distributionen durchgeführt werden.

Anforderungen

Um das Modul für Barman auf einer virtuellen Maschine zu starten, benötigen wir folgende Software:

• VirtualBox
• Landstreicher
• Rubin>=1,9
• Marionette
• Bibliothekar-Marionette

Landstreicher

Vagrant ist ein Manager für virtuelle Maschinen, der viele Virtualisierungssoftware mit VirtualBox als Standard unterstützen kann.

Wir installieren VirtualBox auf diese Weise:

$ sudo apt-get install virtualbox virtualbox-dkms

Die neueste Version von Vagrant kann von der Website heruntergeladen und mit dem folgenden Befehl installiert werden:

$ sudo dpkg -i /path/to/vagrant_1.7.2_x86_64.deb

Rubin

In Bezug auf Ruby empfehlen wir die Verwendung von rbenv , wodurch eine Ruby-Entwicklungsumgebung erstellt wird, in der die Version für den aktuellen Benutzer angegeben werden kann, wodurch eine Kontamination der Systemumgebung vermieden wird. Um rbenv zu installieren Wir empfehlen die Verwendung von rbenv-installer (http://github.com/fesplugas/rbenv-installer).

Lassen Sie uns das Skript herunterladen und ausführen:

$ curl https://raw.githubusercontent.com/fesplugas/rbenv-installer/master/bin/rbenv-installer | bash

Am Ende fordert Sie das Skript auf, die folgenden Zeilen an ~/.bash_profile anzuhängen Datei:

export RBENV_ROOT="${HOME}/.rbenv"

if [ -d "${RBENV_ROOT}" ]; then
  export PATH="${RBENV_ROOT}/bin:${PATH}"
  eval "$(rbenv init -)"
fi

Wir müssen nun das gerade geänderte ~/.bash_profile neu laden :

$ exec bash -l

An diesem Punkt installieren wir lokal eine Ruby-Version (in diesem Fall 2.1.5) und stellen den Benutzer so ein, dass er diese Version anstelle der Systemversion ausführt:

$ rbenv install 2.1.5
$ rbenv global 2.1.5

Marionette

Puppet ist nicht nur auf den VMs erforderlich, sondern auch auf dem Computer, auf dem sie ausgeführt werden. Daher müssen wir das Puppet-Gem installieren.

$ gem install puppet

Bibliothekar-Marionette

Schließlich librarian-puppet ist ein Tool zur Automatisierung der Verwaltung von Puppet-Modulen. Wie Puppet, librarian-puppet kann als Gem installiert werden:

$ gem install librarian-puppet

Vagabund:Konfiguration

Nachdem wir nun die Abhängigkeiten eingerichtet haben, können wir damit beginnen, die Vagrant- und Puppet-Konfigurationen für unser Backup-System zu schreiben.

Wir beginnen mit der Erstellung eines Arbeitsverzeichnisses:

$ mkdir ~/vagrant_puppet_barman
$ cd ~/vagrant_puppet_barman

Vagrant benötigt uns, um eine Datei namens Vagrantfile zu schreiben wo nach der Konfiguration der VMs gesucht wird.

Die folgende Vagrantfile startet zwei Ubuntu Trusty VMs namens pg und backup , mit IP-Adressen 192.168.56.221 und 192.168.56.222 . Auf beiden Maschinen erfolgt die Bereitstellung über ein Inline-Shell-Skript.

Dieses Skript startet puppet-bootstrap (http://github.com/hashicorp/puppet-bootstrap), ein Skript, das Puppet automatisch auf verschiedenen Arten von Maschinen installiert und konfiguriert. Da es nicht mehr als einmal ausgeführt werden muss, wurde in das Skript ein Test eingefügt, um weitere Ausführungen zu verhindern.

Vagrant.configure("2") do |config|
  {
    :pg => {
      :ip      => '192.168.56.221',
      :box     => 'ubuntu/trusty64'
    },
    :backup => {
      :ip      => '192.168.56.222',
      :box     => 'ubuntu/trusty64'
    }
  }.each do |name,cfg|
    config.vm.define name do |local|
      local.vm.box = cfg[:box]
      local.vm.hostname = name.to_s + '.local.lan'
      local.vm.network :private_network, ip: cfg[:ip]
      family = 'ubuntu'
      bootstrap_url = 'http://raw.github.com/hashicorp/puppet-bootstrap/master/' + family + '.sh'

      # Run puppet-bootstrap only once
      local.vm.provision :shell, :inline => <<-eos
        if [ ! -e /tmp/.bash.provision.done ]; then
          curl -L #{bootstrap_url} | bash
          touch /tmp/.bash.provision.done
        fi
      eos
    end
  end
end

Hochfahren der VMs

Wir haben zwei Ubuntu Trusty VMs definiert, die Puppet enthalten. Dies ist nicht die endgültige Vagrantfile ermöglicht aber bereits die Erstellung der beiden Maschinen. Wenn Sie neugierig sind, können Sie mit dem folgenden Befehl überprüfen, ob die beiden Maschinen erstellt wurden:

$ vagrant up

und verbinden Sie sich dann mit den folgenden Befehlen:

$ vagrant ssh pg
$ vagrant ssh backup

Schließlich können die Maschinen zerstört werden mit:

$ vagrant destroy -f

Schlussfolgerungen

In diesem ersten Teil des Tutorials haben wir gesehen, wie die Abhängigkeiten konfiguriert werden, und sind schließlich zu den beiden virtuellen Maschinen gekommen, auf denen wir über Puppet, PostgreSQL und Barman installieren werden. Das Schreiben des Puppet-Manifests für die eigentliche Installation ist das Thema des nächsten Artikels.

Bis bald!