Automatisera Barman med Puppet:it2ndq/barman (del ett)

Detta är inte första gången som 2ndQuadrant tittar på Puppet. Gabriele Bartolini har redan skrivit en artikel i två delar om hur man snabbt konfigurerar en PostgreSQL-server genom Puppet och Vagrant, åtföljd av släppandet av koden som används i exemplet på GitHub (http://github.com/2ndquadrant-it/vagrant) -puppet-postgresql).

Uppdelad i tre delar är syftet med denna artikel att demonstrera automatisering av installationen och konfigurationen av Barman för att säkerhetskopiera en PostgreSQL-testserver.

Den här artikeln är en uppdatering av det som skrevs av Gabriele med idén att skapa två virtuella maskiner istället för en, en PostgreSQL-server och en Barman-server.

it2ndq/barman är modulen som släppts av 2ndQuadrant Italy för att hantera installationen av Barman genom Puppet. Modulen har en GPLv3-licens och är tillgänglig på GitHub på adressen http://github.com/2ndquadrant-it/puppet-barman. Följande procedur skrevs för en Ubuntu 14.04 Trusty Tahr men kan utföras på liknande sätt på andra distributioner.

Krav

För att starta modulen för Barman på en virtuell maskin behöver vi följande programvara:

• VirtualBox
• Lövare
• Ruby>=1.9
• Pocket
• bibliotekarie-docka

Vagrant

Vagrant är en virtuell maskinhanterare som kan stödja många virtualiseringsprogram med VirtualBox som standard.

Vi installerar VirtualBox på detta sätt:

$ sudo apt-get install virtualbox virtualbox-dkms

Den senaste versionen av Vagrant kan laddas ner från webbplatsen och installeras med kommandot:

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

Ruby

När det gäller Ruby är vårt råd att använda rbenv , som skapar en Ruby-utvecklingsmiljö där man kan specificera versionen för den aktuella användaren och därigenom undvika att förorena systemmiljön. För att installera rbenv vi föreslår att du använder rbenv-installer (http://github.com/fesplugas/rbenv-installer).

Låt oss ladda ner och köra skriptet:

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

I slutet kommer skriptet att uppmana dig att lägga till följande rader till ~/.bash_profile fil:

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

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

Vi behöver nu ladda om den nyss ändrade ~/.bash_profile :

$ exec bash -l

Vid det här laget installerar vi en Ruby-version lokalt (i det här fallet 2.1.5) och ställer in användaren på att köra denna version istället för systemversionen:

$ rbenv install 2.1.5
$ rbenv global 2.1.5

Pocket

Puppet krävs inte bara på virtuella datorer utan även på maskinen som kör dem. Därför måste vi installera Puppet gem.

$ gem install puppet

Bibliotekarie-docka

Slutligen, librarian-puppet är ett verktyg för att automatisera hanteringen av Puppet-moduler. Som Puppet, librarian-puppet kan installeras som en pärla:

$ gem install librarian-puppet

Vagrant:konfiguration

Nu när vi har beroenden på plats kan vi börja skriva Vagrant- och Puppet-konfigurationerna för vårt backupsystem.

Vi börjar med att skapa en arbetskatalog:

$ mkdir ~/vagrant_puppet_barman
$ cd ~/vagrant_puppet_barman

Vagrant behöver att vi skriver en fil som heter Vagrantfile där den letar efter konfigurationen av virtuella datorer.

Följande Vagrantfile startar två Ubuntu Trusty virtuella datorer, kallade pg och backup , med ip-adresser 192.168.56.221 och 192.168.56.222 . På båda datorerna kommer provisionering att utföras genom ett inline-skalskript.

Det här skriptet startar puppet-bootstrap (http://github.com/hashicorp/puppet-bootstrap), ett skript som automatiskt installerar och konfigurerar Puppet på olika typer av maskiner. Eftersom det inte behöver köras mer än en gång, infogades ett test i skriptet för att förhindra ytterligare körningar.

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

Ta fram virtuella datorer

Vi har definierat två Ubuntu Trusty virtuella datorer som innehåller Puppet. Detta är inte den sista Vagrantfile men tillåter redan skapandet av de två maskinerna. Om du är nyfiken är det möjligt att verifiera att de två datorerna har skapats med kommandot:

$ vagrant up

och anslut sedan med följande kommandon:

$ vagrant ssh pg
$ vagrant ssh backup

Slutligen kan maskinerna förstöras med:

$ vagrant destroy -f

Slutsatser

I den här första delen av handledningen har vi sett hur man konfigurerar beroenden och slutade med de två virtuella maskiner som vi kommer att installera på, via Puppet, PostgreSQL och Barman. Att skriva Puppet-manifestet för själva installationen kommer att bli föremål för nästa artikel.

Hejdå nu!