Automating Barman with Puppet:it2ndq/barman (prima parte)

Questa non è la prima volta che 2ndQuadrant esamina Puppet. Gabriele Bartolini ha già scritto un articolo in due parti su come configurare rapidamente un server PostgreSQL tramite Puppet e Vagrant, accompagnato dal rilascio del codice utilizzato nell'esempio su GitHub (http://github.com/2ndquadrant-it/vagrant -puppet-postgresql).

Suddiviso in tre parti, lo scopo di questo articolo è dimostrare l'automazione dell'installazione e della configurazione di Barman per il backup di un server di test PostgreSQL.

Questo articolo è un aggiornamento di quanto scritto da Gabriele con l'idea di creare due macchine virtuali invece di una, un server PostgreSQL e un server Barman.

it2ndq/barman è il modulo rilasciato da 2ndQuadrant Italia per gestire l'installazione di Barman tramite Puppet. Il modulo dispone di licenza GPLv3 ed è disponibile su GitHub all'indirizzo http://github.com/2ndquadrant-it/puppet-barman. La procedura seguente è stata scritta per un Trusty Tahr Ubuntu 14.04 ma può essere eseguita in modo simile su altre distribuzioni.

Requisiti

Per avviare il modulo per Barman su una macchina virtuale, abbiamo bisogno del seguente software:

• VirtualBox
• Vagabondo
• Rubino>=1,9
• Pupazzo
• burattino-bibliotecario

Vagabondo

Vagrant è un gestore di macchine virtuali, in grado di supportare molti software di virtualizzazione con VirtualBox di default.

Installiamo VirtualBox in questo modo:

$ sudo apt-get install virtualbox virtualbox-dkms

L'ultima versione di Vagrant può essere scaricata dal sito e installata con il comando:

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

Rubino

Per quanto riguarda Ruby, il nostro consiglio è di usare rbenv , che crea un ambiente di sviluppo Ruby in cui specificare la versione per l'utente corrente, evitando così di contaminare l'ambiente di sistema. Per installare rbenv suggeriamo di utilizzare rbenv-installer (http://github.com/fesplugas/rbenv-installer).

Scarichiamo ed eseguiamo lo script:

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

Alla fine, lo script ti chiederà di aggiungere le seguenti righe a ~/.bash_profile file:

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

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

Ora dobbiamo ricaricare il ~/.bash_profile appena modificato :

$ exec bash -l

A questo punto, installiamo localmente una versione di Ruby (in questo caso, 2.1.5) e impostiamo l'utente in modo che esegua questa versione anziché la versione di sistema:

$ rbenv install 2.1.5
$ rbenv global 2.1.5

Mario

Puppet è richiesto non solo sulle VM ma anche sulla macchina che le esegue. Quindi dobbiamo installare la gemma Puppet.

$ gem install puppet

Il burattino-bibliotecario

Infine, librarian-puppet è uno strumento per automatizzare la gestione dei moduli Puppet. Come Puppet, librarian-puppet può essere installato come una gemma:

$ gem install librarian-puppet

Vagante:configurazione

Ora che abbiamo le dipendenze in atto, possiamo iniziare a scrivere le configurazioni Vagrant e Puppet per il nostro sistema di backup.

Iniziamo creando una directory di lavoro:

$ mkdir ~/vagrant_puppet_barman
$ cd ~/vagrant_puppet_barman

Vagrant ha bisogno che noi scriviamo un file chiamato Vagrantfile dove cerca la configurazione delle VM.

Il seguente Vagrantfile avvia due macchine virtuali Ubuntu Trusty, chiamate pg e backup , con indirizzi IP 192.168.56.221 e 192.168.56.222 . Su entrambe le macchine il provisioning verrà eseguito tramite uno script di shell inline.

Questo script avvia puppet-bootstrap (http://github.com/hashicorp/puppet-bootstrap), uno script che installa e configura automaticamente Puppet su vari tipi di macchine. Poiché non è necessario eseguirlo più di una volta, nello script è stato inserito un test per impedire ulteriori esecuzioni.

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

Aprire le VM

Abbiamo definito due VM Ubuntu Trusty contenenti Puppet. Questo non è il Vagrantfile finale ma consente già la creazione delle due macchine. Se sei curioso, è possibile verificare che le due macchine siano state create con il comando:

$ vagrant up

e quindi connetterti utilizzando i seguenti comandi:

$ vagrant ssh pg
$ vagrant ssh backup

Infine, le macchine possono essere distrutte con:

$ vagrant destroy -f

Conclusioni

In questa prima parte del tutorial abbiamo visto come configurare le dipendenze e siamo arrivati ​​alle due macchine virtuali su cui installeremo, tramite Puppet, PostgreSQL e Barman. La scrittura del manifesto dei pupazzi per l'installazione vera e propria sarà oggetto del prossimo articolo.

Ciao per ora!