Automatizando o Barman com Puppet:it2ndq/barman (parte um)

Esta não é a primeira vez que o 2ndQuadrant analisa o Puppet. Gabriele Bartolini já escreveu um artigo em duas partes sobre como configurar rapidamente um servidor PostgreSQL através do Puppet e do Vagrant, acompanhado do lançamento do código usado no exemplo no GitHub (https://github.com/2ndquadrant-it/vagrant -puppet-postgresql).

Dividido em três partes, o objetivo deste artigo é demonstrar a automação da instalação e configuração do Barman para backup de um servidor de teste PostgreSQL.

Este artigo é uma atualização do que foi escrito por Gabriele com a ideia de criar duas máquinas virtuais ao invés de uma, um servidor PostgreSQL e um servidor Barman.

it2ndq/barman é o módulo lançado pela 2ndQuadrant Italy para gerenciar a instalação do Barman através do Puppet. O módulo possui licença GPLv3 e está disponível no GitHub no endereço https://github.com/2ndquadrant-it/puppet-barman. O procedimento a seguir foi escrito para um Ubuntu 14.04 Trusty Tahr, mas pode ser executado de maneira semelhante em outras distribuições.

Requisitos

Para iniciar o módulo do Barman em uma máquina virtual, precisamos do seguinte software:

VirtualBox
Vagabunda
Rubi>=1,9
Marionete
bibliotecário-fantoche

Vagabundo

Vagrant é um gerenciador de máquinas virtuais, capaz de suportar muitos softwares de virtualização com VirtualBox como padrão.

Instalamos o VirtualBox desta forma:

$ sudo apt-get install virtualbox virtualbox-dkms

A última versão do Vagrant pode ser baixada do site e instalada com o comando:

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

Rubi

Em relação ao Ruby, nosso conselho é usar rbenv , que cria um ambiente de desenvolvimento Ruby no qual especificar a versão para o usuário atual, evitando assim a contaminação do ambiente do sistema. Para instalar o rbenv sugerimos usar o rbenv-installer (https://github.com/fesplugas/rbenv-installer).

Vamos baixar e executar o script:

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

No final, o script solicitará que você anexe as seguintes linhas ao ~/.bash_profile Arquivo:

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

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

Agora precisamos recarregar o ~/.bash_profile recém-alterado :

$ exec bash -l

Neste ponto, instalamos localmente uma versão do Ruby (neste caso, 2.1.5) e configuramos o usuário para executar esta versão em vez da versão do sistema:

$ rbenv install 2.1.5
$ rbenv global 2.1.5

Fantoche

O Puppet é necessário não apenas nas VMs, mas também na máquina que as executa. Portanto, precisamos instalar a gem Puppet.

$ gem install puppet

Bibliotecário-fantoche

Por fim, librarian-puppet é uma ferramenta para automatizar o gerenciamento dos módulos Puppet. Como Puppet, librarian-puppet pode ser instalado como uma gem:

$ gem install librarian-puppet

Vagrant:configuração

Agora que temos as dependências no lugar, podemos começar a escrever as configurações Vagrant e Puppet para nosso sistema de backup.

Começamos criando um diretório de trabalho:

$ mkdir ~/vagrant_puppet_barman
$ cd ~/vagrant_puppet_barman

Vagrant precisa que escrevamos um arquivo chamado Vagrantfile onde procura a configuração das VMs.

O seguinte Vagrantfile inicia duas VMs do Ubuntu Trusty, chamadas pg e backup , com endereços IP 192.168.56.221 e 192.168.56.222 . Em ambas as máquinas, o provisionamento será realizado por meio de um script de shell embutido.

Este script inicia o puppet-bootstrap (https://github.com/hashicorp/puppet-bootstrap), um script que instala e configura automaticamente o Puppet em vários tipos de máquinas. Como não precisa ser executado mais de uma vez, no script foi inserido um teste para evitar futuras execuções.

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 = 'https://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

Abrindo as VMs

Definimos duas VMs Ubuntu Trusty contendo Puppet. Este não é o Vagrantfile final mas já permite a criação das duas máquinas. Caso tenha curiosidade, é possível verificar se as duas máquinas foram criadas com o comando:

$ vagrant up

e, em seguida, conectar usando os seguintes comandos:

$ vagrant ssh pg
$ vagrant ssh backup

Finalmente, as máquinas podem ser destruídas com:

$ vagrant destroy -f

Conclusões

Nesta primeira parte do tutorial vimos como configurar as dependências e acabamos com as duas máquinas virtuais nas quais vamos instalar, via Puppet, PostgreSQL e Barman. Escrever o manifesto Puppet para a instalação real será o assunto do próximo artigo.

Adeus por agora!