Automatización de Barman con Puppet:it2ndq/barman (primera parte)

Esta no es la primera vez que 2ndQuadrant analiza a Puppet. Gabriele Bartolini ya ha escrito un artículo en dos partes sobre cómo configurar rápidamente un servidor PostgreSQL a través de Puppet y Vagrant, acompañado del lanzamiento del código utilizado en el ejemplo en GitHub (http://github.com/2ndquadrant-it/vagrant -puppet-postgresql).

Dividido en tres partes, el objetivo de este artículo es demostrar la automatización de la instalación y configuración de Barman para respaldar un servidor de prueba de PostgreSQL.

Este artículo es una actualización de lo escrito por Gabriele con la idea de crear dos máquinas virtuales en lugar de una, un servidor PostgreSQL y un servidor Barman.

it2ndq/barman es el módulo lanzado por 2ndQuadrant Italia para gestionar la instalación de Barman a través de Puppet. El módulo tiene una licencia GPLv3 y está disponible en GitHub en la dirección http://github.com/2ndquadrant-it/puppet-barman. El siguiente procedimiento se escribió para Ubuntu 14.04 Trusty Tahr, pero se puede realizar de manera similar en otras distribuciones.

Requisitos

Para iniciar el módulo para Barman en una máquina virtual, necesitamos el siguiente software:

• Caja virtual
• vagabundo
• Rubí>=1.9
• Marioneta
• títere-bibliotecario

Vagabundo

Vagrant es un administrador de máquinas virtuales, capaz de admitir muchos softwares de virtualización con VirtualBox como opción predeterminada.

Instalamos VirtualBox de esta manera:

$ sudo apt-get install virtualbox virtualbox-dkms

La última versión de Vagrant se puede descargar del sitio e instalar con el comando:

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

Rubí

Con respecto a Ruby, nuestro consejo es usar rbenv , que crea un entorno de desarrollo de Ruby en el que especificar la versión para el usuario actual, evitando así contaminar el entorno del sistema. Para instalar rbenv sugerimos usar rbenv-installer (http://github.com/fesplugas/rbenv-installer).

Descarguemos y ejecutemos el script:

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

Al final, el script le pedirá que agregue las siguientes líneas al ~/.bash_profile archivo:

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

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

Ahora necesitamos volver a cargar el ~/.bash_profile recién modificado :

$ exec bash -l

En este punto, instalamos localmente una versión de Ruby (en este caso, 2.1.5) y configuramos al usuario para que ejecute esta versión en lugar de la versión del sistema:

$ rbenv install 2.1.5
$ rbenv global 2.1.5

Marioneta

Se requiere Puppet no solo en las máquinas virtuales sino también en la máquina que las ejecuta. Por lo tanto, necesitamos instalar la gema Puppet.

$ gem install puppet

Bibliotecario-títere

Finalmente, librarian-puppet es una herramienta para automatizar la gestión de módulos Puppet. Como Marioneta, librarian-puppet se puede instalar como una joya:

$ gem install librarian-puppet

Vagrante:configuración

Ahora que tenemos las dependencias en su lugar, podemos comenzar a escribir las configuraciones de Vagrant y Puppet para nuestro sistema de respaldo.

Empezamos creando un directorio de trabajo:

$ mkdir ~/vagrant_puppet_barman
$ cd ~/vagrant_puppet_barman

Vagrant necesita que escribamos un archivo llamado Vagrantfile donde busca la configuración de las VMs.

El siguiente Vagrantfile inicia dos máquinas virtuales Ubuntu Trusty, llamadas pg y backup , con direcciones IP 192.168.56.221 y 192.168.56.222 . En ambas máquinas, el aprovisionamiento se realizará a través de un script de shell en línea.

Este script inicia puppet-bootstrap (http://github.com/hashicorp/puppet-bootstrap), un script que instala y configura automáticamente Puppet en varios tipos de máquinas. Como no es necesario ejecutarlo más de una vez, en el script se insertó una prueba para evitar más ejecuciones.

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

Abrir las máquinas virtuales

Hemos definido dos máquinas virtuales Ubuntu Trusty que contienen Puppet. Este no es el Vagrantfile final pero ya permite la creación de las dos máquinas. Si tiene curiosidad, es posible verificar que las dos máquinas se han creado con el comando:

$ vagrant up

y luego conectarse usando los siguientes comandos:

$ vagrant ssh pg
$ vagrant ssh backup

Finalmente, las máquinas se pueden destruir con:

$ vagrant destroy -f

Conclusiones

En esta primera parte del tutorial hemos visto cómo configurar las dependencias y terminamos con las dos máquinas virtuales en las que instalaremos, a través de Puppet, PostgreSQL y Barman. Escribir el manifiesto de Puppet para la instalación real será el tema del próximo artículo.

¡Adiós por ahora!