Servidor de desarrollo Django con Vagrant y Ansible

Vagrant es una de esas herramientas que a priori parece que no tiene cabida en tu stack, pero una vez que comienzas a utilizarla se vuelve indispensable. En una entrada anterior vimos como hacer uso de la misma con el driver de Digital Ocean**,** en ese caso para desplegar Droplets, aunque el objetivo principal de esta herramienta es crear entornos de desarrollo aislados.

Vagrant permite que el abastecimiento de las máquinas a través de un script Bash o por medio de cualquier herramienta de orquestación tipo Puppet, Salt, Cheff o Ansible. En esta ocasión utilizaremos Ansible para el aprovisionar nuestro entorno.

En esta serie de artículos veremos como crear un servidor de desarrollo aislado para Django. Te preguntarás, ¿pero si con Python ya tenemos virtualenv? Si, pero ya sabemos que virtualenv no es perfecto y en muchas ocasiones no aísla todo lo bien que debería. Además Vagrant nos permite replicar el entorno de producción en local, con todas las ventajas que conlleva desarrollar en el entorno que nos vamos a encontrar en producción. En este ejemplo utilizaremos Ubuntu 16.04 cómo sistema operativo, Nginx de proxy inverso, Postgree como sistema gestor de base de datos y Gunicorn de servidor web.

Por qué Ansible

La diferencia principal entre Ansible y otras herramientas de orquestación, es que Ansible se comunica con el/los servidor/es vía SSH, no como Puppet o Chef que necesitan tener instaladas dependencias en el/los servidor/es para poder ser utilizados.

La principal ventaja de Ansible es su simplicidad, las tareas se definen en formato YAML, tiene una comunidad inmensa (cuenta más seguidores en Github que Salt, Puppet y Cheff juntos). Por si fuera poco está escrito en Python y permite el uso de plantillas Jinja 2 para generar ficheros de configuración.

Gracias a Ansible podremos replicar la máquina orquestada para desarrollo en producción sin demasiado coste adicional, dedicaré un artículo en el futuro para tratar esta problemática.

Requisitos

Antes que nada tenemos que tener instalado en nuestro equipo Vagrant y Ansible. Vagrant lo puedes descargar desde aquí, Ansible lo puedes instalar con Brew o con PIP, tal como indican en la documentación oficial.

Vagrantfile

Comenzaremos creando un nuevo directorio para nuestro proyecto:

mkdir -p ~/Projects/ansible-vagrant-django
cd ~/Projects/ansible-vagrant-django

A continuación, ejecutaremos el comando

Vagrant init

para crear un nuevo

Vagrantfile

basado en Ubuntu 16.04:

vagrant init geerlingguy/ubuntu1604

Debe haberse generado un fichero llamado Vagrantfile en la raíz del directorio. Este contiene información básica sobre la máquina que queremos aprovisionar, y multiples comentarios, los eliminamos y dejamos el fichero así:

API_VERSION = "2"

Vagrant.configure(API_VERSION) do |config|
  config.vm.box = "geerlingguy/ubuntu1604"
end

Vamos a necesitar una manera de acceder a nuestro servidor web una vez que la máquina esté lista, así que le indicaremos a Vagrant que mapee el puerto 8000 de nuestro equipo al puerto 8000 de la maquina virtual. Para ello, agrega el siguiente código:

config.vm.network "forwarded_port", guest: 80, host: 8080
config.vm.network "public_network"

Para poder acceder vía SSH a nuestra máquina y que sincronice nuestro directorio de trabajo dentro de la máquina, necesitaremos añadir estás dos directivas:

config.ssh.forward_agent = true
config.vm.synced_folder "./", "/var/www/djangoproject"

Por último, indicaremos que queremos aprovisionar la máquina con Ansible, y dónde va a encontrar el fichero con los comandos de ansible:

config.vm.provision :ansible do |ansible|
  ansible.playbook = "provision/vagrant.yml"
end

Una vez añadidos todos los requerimientos nuestro Vagrantfile quedará así:

    # -*- mode: ruby -*-
# vi: set ft=ruby :

API_VERSION = "2"

Vagrant.configure(API_VERSION) do |config|

  config.vm.box = "geerlingguy/ubuntu1604"

  config.vm.network "forwarded_port", guest: 8000, host: 8000
  config.vm.network "public_network"

  config.ssh.forward_agent = true
  config.vm.synced_folder "./", "/var/www/djangoproject"

  config.vm.provision "ansible" do |ansible|
    ansible.playbook = "provision/vagrant.yml"
  end
end

Playbooks de Ansible

Un Playbook de Ansible es un fichero que permite definir todas las tareas que se van a realizar en uno o varios hosts (servidores), en este caso en nuestro servidor de desarrollo.

Las tareas equivalen a uno o multiples comandos bash, cada una de las mismas hace uso de un modulo de Ansible. Los módulos son librerías que utiliza Ansible para controlar servicios, ficheros, paquetes o comandos, como por ejemplo apt, copy o service.

Veamos como escribir nuestro primer Playbook, lo primero que debemos hacer es crear un directorio provision y dentro de este un fichero denominado vagrant.yml:

mkdir provision
cd provision
touch vagrant.yml

Seguidamente añadimos a nuestro playbook los hosts en los que se van a ejecutar las tareas, en este caso como estamos haciendo uso de Vagrant indicaremos que puede ejecutar las tareas en todos los servidores conocidos y además con permisos de usuario root (become yes):

- hosts: all
  become: yes

Tareas de Ansible

Tal como hemos dicho, las tareas (Tasks) de Ansible realizan su función ejecutando un modulo, son ejecutadas en orden, una cada vez en cada uno de los nodos definidos en la directiva ‘hosts’ (en este caso sólo tenemos el nodo de nuestra máquina virtual).
Cada una de las tareas tienen como mínimo un nombre y el módulo que ejecutan. Por ejemplo, instalar python-pip sería tan sencillo como esto:

- name: Install python pip
  apt: name=python-pip

En este artículo, para evitar que se haga excesivamente extenso, solo crearemos la tarea “instalar los paquetes básicos”, dejaremos para la próxima entrada las tareas referentes a la configuración de PosgtgreeSQL, Nginx, Gunicorn y Django.
Dicha tarea quedaría tal que así:

- name: Install base packages
  apt: name={{ item }} update_cache=yes state=installed
  with_items:
    - build-essential
    - acl
    - ntp
    - htop
    - git
    - libpq-dev
    - python-dev
    - python-pip
    - python-pycurl
    - nginx
    - gunicorn

En esta tarea estamos ejecutando el modulo apt, le estamos indicando que actualice la caché y que el estado de final de la tarea sea “installed”. La directiva “with_items” permite que la tarea se ejecute para cada uno de los paquetes indicados.

Así luce nuestro playbook hasta el momento:

---
- hosts: all
  become: yes

  tasks:
    - name: Install base packages
      apt: name={{ item }} update_cache=yes state=installed
      with_items:
        - build-essential
        - acl
        - ntp
        - htop
        - git
        - libpq-dev
        - python-dev
        - python-pip
        - python-pycurl
        - nginx
        - gunicorn

Si a continuación ejecutamos el comando

vagrant up

se “levantará” nuestra máquina con la “box” asignada, en este caso Ubuntu 16.04, y la configuración que hemos indicado en el vagrantfile.

Una vez terminado este proceso, y sólo si es la primera vez que se ejecuta, comenzará el aprovisionamiento de la máquina con nuestro playbook de Ansible. Si añadimos tareas a posteriori al playbook podemos volver a ejecutar el aprovisionamiento con el comando

vagrant provision

.

Resumen

En esta entrada hemos visto cómo configurar un servidor de desarrollo casi genérico usando Vagrant y Ansible. He dejado muchas cosas en el tintero, pero el post se estaba haciendo demasiado largo. En el siguiente entraré en materia en lo referente a la configuración del stack de Django y continuaré profundizando en lo que a Ansible se refiere, trateré temas como Roles, Handlers, Vars y demás.

Si te ha gustado la entrada valora y comparte en tus redes sociales. No dudes en comentar dudas, aportes o sugerencias, estaré encantado de responder.

Este artículo se distribuye bajo una Licencia Creative Commons Reconocimiento-CompartirIgual 4.0 Internacional (CC BY-SA 4.0)