django vagrant ansible

Servidor de desarrollo Django con Vagrant y Ansible (parte 1)

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)

licencia-cc

docker swarm digital ocean

Cluster de servidores con Docker Swarm en Digital Ocean

Docker Swarm es una herramienta integrada en el ecosistema de Docker que permite la gestión de un cluster de servidores. Pone a nuestra disposición una API con la que podemos administrar las  tareas y asignación de recursos de cada contenedor dentro de cada una de las máquinas. Dicha API nos permite gestionar el cluster como si se tratase de una sola máquina Docker.

En este artículo veremos cómo construir un cluster de servidores con Docker Swarm, se utilizará Docker Machine con el driver de Digital Ocean para aprovisionar cada una de las máquinas.

Docker Swarm

 

La mejor manera de orquestar docker es con el propio docker Click Para Twittear

Requisitos

Para seguir este tutorial necesitamos los siguiente:

  • Tener instalado docker en tu máquina (puedes instalarlo desde aquí)
  • Disponer de un token de API de Digital Ocean. Si no lo tienes puedes generar uno siguiendo esta guía.

Generar el token de Swarm

El sistema de descubrimiento de nodos de Swarm, Discovery Service, se sirve de un token para reconocer todos nodos que forman parte de un clúster. Veamos como generar dicho token para poder hacer uso de Discovery Service.

En primer lugar guardaremos en una variable de sesión el token de Digital Ocean:

export DO_TOKEN="abcdefghijklmnopqrstuvwxyz1234567890"

A continuación, creamos una maquina con docker machine llamada swarm-1, dicha máquina servirá simplemente para generar el token de cluster:

docker-machine create \
--driver digitalocean \
--digitalocean-access-token ${DO_TOKEN} \
--digitalocean-image "ubuntu-16-04-x64" \
--digitalocean-region "lon1" \
--digitalocean-size "512mb" \
swarm-1

Seleccionamos esta maquina:

eval $(docker-machine env swarm-1)

Generamos el token de cluster:

docker run swarm create

Almacenamos en una variable de entorno dicho token y lo exportamos:

export SWARM_TOKEN=61ef79938e5559d480c2841991c49f5d

Ya podemos eliminar esta instancia de digital ocean, como hemos dicho sólo la necesitabamos para crear el ID.

docker-machine rm swarm-1

Nodo principal (Swarm Master)

Es el encargado de gestionar los recursos del clúster. Para crearlo ejecutaremos el siguiente código:

docker-machine create \
--driver digitalocean \
--digitalocean-access-token ${DO_TOKEN} \
--digitalocean-image "ubuntu-16-04-x64" \
--digitalocean-region "lon1" \
--digitalocean-size "512mb" \
--swarm --swarm-master \
--swarm-discovery token://${SWARM_TOKEN} \
swarm-master

Nodos secundarios

Una vez creado el nodo principal ya podemos añadir los nodos secundarios que necesitemos, en este caso vamos a añadir dos nodos al cluster:
Nodo 1:

docker-machine create \
--driver digitalocean \
--digitalocean-access-token ${DO_TOKEN} \
--digitalocean-image "ubuntu-16-04-x64" \
--digitalocean-region "lon1" \
--digitalocean-size "512mb" \
--swarm \
--swarm-discovery token://${SWARM_TOKEN} \
swarm-node-1

Nodo 2:

docker-machine create \
--driver digitalocean \
--digitalocean-access-token ${DO_TOKEN} \
--digitalocean-image "ubuntu-16-04-x64" \
--digitalocean-region "lon1" \
--digitalocean-size "512mb" \
--swarm \
--swarm-discovery token://${SWARM_TOKEN} \
swarm-node-2

Comprobamos que todos los nodos están funcionan correctamente

docker-machine ls

Si seleccionamos unos de los nodos: eval $(docker-machine env --swarm swarm-master)y, ejecutamos docker info, podremos ver la información de los dos nodos secundarios y del nodo principal, containers, CPUs, Memoria kernel.

Contenedores en el clúster

Vamos a ejecutar dos contenedores con la imagen nginx y aplicando una limitación de 400M de memoria a cada uno de los contenedores

docker run --name web-1 -d -P -m 400M nginx

Podemos comprobar si el contenedor está ejecutandose correctamente con docker ps. Observamos que el planificador de docker swarm ha escogido para correr el contenedor web-1 el nodo principal.

Veamos que ocurre si inicializamos otro contenedor denominado “web-2” con las mismas restricciones que el anterior:

docker run --name web-2 -d -P -m 400M nginx

En esta ocasión, el planificador ha asignado el contenedor al nodo 1, porque no había suficiente memoria en el nodo principal.

Si lo consideramos necesario podemos ampliar el tamaño del cluster, ejecutando simplemente:

docker-machine create \
--driver digitalocean \
--digitalocean-access-token ${DO_TOKEN} \
--digitalocean-image "ubuntu-16-04-x64" \
--digitalocean-region "lon1" \
--digitalocean-size "512mb" \
--swarm \
--swarm-discovery token://${SWARM_TOKEN} \
swarm-node-3

Conclusión

Hemos podido ver que orquestar hosts de Docker con Docker Swarm es un proceso relativamente sencillo. Poco a poco el ecosistema de docker se está volviendo más robusto y completo. En el caso concreto de Swarm,  personalmente aun no lo utilizaría en entornos de producción, pero como hemos podido ver es una herramienta que promete mucho.

Happy clustering!!

Desplegando instancias de DigitalOcean con Vagrant

Vagrant es una potente herramienta open source para la configuración y despliegue de múltiples entornos, tanto de desarrollo, como de producción. Está diseñado para funcionar en Linux, Mac OS X o Windows. Por defecto utiliza VirtualBox para la capa de virtualización, se puede utilizar también con otros proveedores como VMware o AWS. En esta entrada vamos a configurarlo utilizando el driver de DigitalOcean como proveedor.

Leer más