Automatyzacja Barmana z Puppet:it2ndq/barman (część pierwsza)

To nie pierwszy raz, kiedy 2nd Quadrant przygląda się Puppetowi. Gabriele Bartolini napisał już artykuł w dwóch częściach o tym, jak szybko skonfigurować serwer PostgreSQL za pomocą Puppet i Vagrant, wraz z wydaniem kodu użytego w przykładzie na GitHub (http://github.com/2ndquadrant-it/vagrant -puppet-postgresql).

Podzielony na trzy części, celem tego artykułu jest zademonstrowanie automatyzacji instalacji i konfiguracji Barmana w celu wykonania kopii zapasowej serwera testowego PostgreSQL.

Ten artykuł jest aktualizacją tego, co napisała Gabriele z myślą o stworzeniu dwóch maszyn wirtualnych zamiast jednej, serwera PostgreSQL i serwera Barman.

it2ndq/barman to moduł wydany przez 2ndQuadrant Italy do zarządzania instalacją Barmana za pośrednictwem Puppet. Moduł posiada licencję GPLv3 i jest dostępny w serwisie GitHub pod adresem http://github.com/2ndquadrant-it/puppet-barman. Poniższa procedura została napisana dla Ubuntu 14.04 Trusty Tahr, ale można ją wykonać w podobny sposób w innych dystrybucjach.

Wymagania

Aby uruchomić moduł dla Barmana na maszynie wirtualnej, potrzebujemy następującego oprogramowania:

• Skrzynka wirtualna
• Włóczęga
• Rubin>=1,9
• Lalka
• biblioteka-laleczka

Włóczęga

Vagrant to menedżer maszyn wirtualnych, który może obsługiwać wiele programów do wirtualizacji z domyślnym VirtualBox.

Instalujemy VirtualBox w ten sposób:

$ sudo apt-get install virtualbox virtualbox-dkms

Najnowszą wersję Vagranta można pobrać ze strony i zainstalować za pomocą polecenia:

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

Rubin

Jeśli chodzi o Rubiego, naszą radą jest użycie rbenv , który tworzy środowisko programistyczne Ruby, w którym można określić wersję dla bieżącego użytkownika, unikając w ten sposób zanieczyszczenia środowiska systemowego. Aby zainstalować rbenv sugerujemy użycie rbenv-installer (http://github.com/fesplugas/rbenv-installer).

Pobierzmy i uruchommy skrypt:

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

Na koniec skrypt poprosi o dodanie następujących linii do ~/.bash_profile plik:

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

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

Teraz musimy ponownie załadować właśnie zmieniony ~/.bash_profile :

$ exec bash -l

W tym momencie instalujemy lokalnie wersję Ruby (w tym przypadku 2.1.5) i ustawiamy użytkownika, aby uruchamiał tę wersję, a nie wersję systemową:

$ rbenv install 2.1.5
$ rbenv global 2.1.5

Lalka

Puppet jest wymagany nie tylko na maszynach wirtualnych, ale także na maszynie, na której są one uruchomione. Dlatego musimy zainstalować klejnot Marionetek.

$ gem install puppet

biblioteka-laleczka

Wreszcie librarian-puppet to narzędzie do automatyzacji zarządzania modułami Puppet. Podobnie jak Puppet, librarian-puppet można zainstalować jako klejnot:

$ gem install librarian-puppet

Włóczęga:konfiguracja

Teraz, gdy mamy już zależności, możemy zacząć pisać konfiguracje Vagrant i Puppet dla naszego systemu kopii zapasowych.

Zaczynamy od stworzenia katalogu roboczego:

$ mkdir ~/vagrant_puppet_barman
$ cd ~/vagrant_puppet_barman

Vagrant potrzebuje nas do napisania pliku o nazwie Vagrantfile gdzie szuka konfiguracji maszyn wirtualnych.

Następujący Vagrantfile uruchamia dwie maszyny wirtualne Ubuntu Trusty o nazwie pg i backup , z adresami IP 192.168.56.221 i 192.168.56.222 . Na obu komputerach obsługa administracyjna będzie wykonywana za pomocą wbudowanego skryptu powłoki.

Ten skrypt uruchamia puppet-bootstrap (http://github.com/hashicorp/puppet-bootstrap), skrypt, który automatycznie instaluje i konfiguruje Puppet na różnych typach maszyn. Ponieważ nie trzeba go uruchamiać więcej niż raz, w skrypcie wstawiono test, aby zapobiec dalszym wykonaniom.

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

Wywoływanie maszyn wirtualnych

Zdefiniowaliśmy dwie maszyny wirtualne Ubuntu Trusty zawierające Puppet. To nie jest ostateczny Vagrantfile ale już pozwala na stworzenie dwóch maszyn. Jeśli jesteś ciekawy, możesz sprawdzić, czy dwie maszyny zostały utworzone za pomocą polecenia:

$ vagrant up

a następnie łączenie za pomocą następujących poleceń:

$ vagrant ssh pg
$ vagrant ssh backup

Wreszcie maszyny można zniszczyć za pomocą:

$ vagrant destroy -f

Wnioski

W tej pierwszej części samouczka zobaczyliśmy, jak skonfigurować zależności i otrzymaliśmy dwie wirtualne maszyny, na których zainstalujemy, za pośrednictwem Puppet, PostgreSQL i Barman. Napisanie manifestu Puppet dla rzeczywistej instalacji będzie tematem następnego artykułu.

Na razie do widzenia!