Barman automatiseren met Puppet:it2ndq/barman (deel één)

Dit is niet de eerste keer dat 2ndQuadrant naar Puppet kijkt. Gabriele Bartolini heeft al een artikel in twee delen geschreven over het snel configureren van een PostgreSQL-server via Puppet en Vagrant, vergezeld van de vrijgave van de code die in het voorbeeld wordt gebruikt op GitHub (http://github.com/2ndquadrant-it/vagrant -puppet-postgresql).

Het is opgedeeld in drie delen en het doel van dit artikel is om de automatisering van de installatie en configuratie van Barman te demonstreren om een ​​back-up van een PostgreSQL-testserver te maken.

Dit artikel is een update van wat is geschreven door Gabriele met het idee om twee virtuele machines te maken in plaats van één, een PostgreSQL-server en een Barman-server.

it2ndq/barman is de module vrijgegeven door 2ndQuadrant Italië om de installatie van Barman via Puppet te beheren. De module heeft een GPLv3-licentie en is beschikbaar op GitHub op het adres http://github.com/2ndquadrant-it/puppet-barman. De volgende procedure is geschreven voor een Ubuntu 14.04 Trusty Tahr, maar kan op een vergelijkbare manier worden uitgevoerd op andere distributies.

Vereisten

Om de module voor Barman op een virtuele machine te starten, hebben we de volgende software nodig:

• VirtualBox
• Dwaalgast
• Ruby>=1,9
• Marionet
• bibliothecaris-pop

Dwaalgast

Vagrant is een virtuele machinemanager die veel virtualisatiesoftware kan ondersteunen met VirtualBox als standaard.

We installeren VirtualBox op deze manier:

$ sudo apt-get install virtualbox virtualbox-dkms

De nieuwste versie van Vagrant kan van de site worden gedownload en worden geïnstalleerd met het commando:

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

Ruby

Wat Ruby betreft, is ons advies om rbenv . te gebruiken , die een Ruby-ontwikkelomgeving creëert waarin de versie voor de huidige gebruiker kan worden gespecificeerd, waardoor besmetting van de systeemomgeving wordt voorkomen. rbenv installeren we raden aan om rbenv-installer . te gebruiken (http://github.com/fesplugas/rbenv-installer).

Laten we het script downloaden en uitvoeren:

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

Aan het einde zal het script u vragen om de volgende regels toe te voegen aan het ~/.bash_profile bestand:

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

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

We moeten nu het zojuist gewijzigde ~/.bash_profile . opnieuw laden :

$ exec bash -l

Op dit punt installeren we lokaal een Ruby-versie (in dit geval 2.1.5) en stellen we de gebruiker in om deze versie uit te voeren in plaats van de systeemversie:

$ rbenv install 2.1.5
$ rbenv global 2.1.5

Marionet

Puppet is niet alleen vereist op de VM's, maar ook op de machine waarop ze worden uitgevoerd. Daarom moeten we de Puppet-edelsteen installeren.

$ gem install puppet

Bibliothecaris-pop

Tot slot, librarian-puppet is een tool om het beheer van Puppet-modules te automatiseren. Net als Puppet, librarian-puppet kan als een juweeltje worden geïnstalleerd:

$ gem install librarian-puppet

Dwaalgast:configuratie

Nu we de afhankelijkheden hebben, kunnen we beginnen met het schrijven van de Vagrant- en Puppet-configuraties voor ons back-upsysteem.

We beginnen met het maken van een werkmap:

$ mkdir ~/vagrant_puppet_barman
$ cd ~/vagrant_puppet_barman

Vagrant heeft ons nodig om een ​​bestand te schrijven met de naam Vagrantfile waar het zoekt naar de configuratie van de VM's.

Het volgende Vagrantfile start twee Ubuntu Trusty VM's, genaamd pg en backup , met ip-adressen 192.168.56.221 en 192.168.56.222 . Op beide machines wordt de provisioning uitgevoerd via een inline shellscript.

Dit script start puppet-bootstrap (http://github.com/hashicorp/puppet-bootstrap), een script dat Puppet automatisch op verschillende soorten machines installeert en configureert. Omdat het niet meer dan één keer hoeft te worden uitgevoerd, is in het script een test ingevoegd om verdere uitvoeringen te voorkomen.

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

Opstarten van de VM's

We hebben twee Ubuntu Trusty VM's gedefinieerd die Puppet bevatten. Dit is niet de laatste Vagrantfile maar maakt het al mogelijk om de twee machines te maken. Als je nieuwsgierig bent, is het mogelijk om te controleren of de twee machines zijn gemaakt met het commando:

$ vagrant up

en vervolgens verbinding maken met behulp van de volgende opdrachten:

$ vagrant ssh pg
$ vagrant ssh backup

Ten slotte kunnen de machines worden vernietigd met:

$ vagrant destroy -f

Conclusies

In dit eerste deel van de tutorial hebben we gezien hoe we de afhankelijkheden moeten configureren en zijn we uitgekomen op de twee virtuele machines waarop we zullen installeren, via Puppet, PostgreSQL en Barman. Het schrijven van het Puppet-manifest voor de daadwerkelijke installatie zal het onderwerp zijn van het volgende artikel.

Tot ziens!