¿Qué es Ansible?

Ansible es una herramienta que nos permite gestionar configuraciones, aprovisionamiento de recursos, despliegue automático de aplicaciones y muchas otras tareas de TI de una forma limpia y sencilla.

¿En qué se diferencia de otras herramientas similares?

  • No necesita agentes
  • No requiere de configuraciones engorrosas y complicadas
  • Flexibilidad (API, Módulos, Plugins)
  • Facilidad de uso

¿Quiénes usan Ansible actualmente?

Por su simplicidad Ansible es utilizado por muchísimas empresas. Entre ellas:

Y desde ahora Deiser.

Instalar Ansible

La instalación es bastante simple, una vez instalado no encontraras base de datos o algún demonio que monitorizar o inicializar.

Sólo es necesario instalarlo en una máquina, que actuará como punto central de la aplicación. Cabe destacar que Ansible no necesita software o herramientas en los nodos donde se ejecute, por lo que el mantenimiento y actualización de la versión es muy sencillo.

¿Qué vamos a necesitar?

Para poder avanzar, es necesario disponer de 2 máquinas virtuales. Para efectos
de esta guía usaremos Ubuntu como sistema operativo en ambos equipos.

  • Máquina central: Con IP 192.168.101.103
  • Nodo: Con IP 192.168.101.104

Máquina central (192.168.101.103)

Los requerimientos son los siguientes:

  • Python 2.6+
  • Sistema operativo: Red Hat, Debian, CentOS, OS X. Windows no soportado para la máquina central

Nodo (192.168.101.104)

Los requerimientos son los siguientes:

  • Python 2.5+

Si la versión de Python es inferior, será necesario disponer de: python-simplejson

Para la instalación de la máquina central se deben seguir los siguientes pasos:

YUM

Existen RPM's disponibles para EPEL 6 y 7

$ sudo yum install ansible

APT-Ubuntu

$ sudo apt-get install software-properties-common
$ sudo apt-add-repository ppa:ansible/ansible
$ sudo apt-get update
$ sudo apt-get install ansible

Debian

$ sudo apt-get update
$ sudo apt-get install python-pip python-dev git -y
$ sudo pip install PyYAML jinja2 paramiko
$ git clone https://github.com/ansible/ansible.git
$ cd ansible
$ sudo make install
$ sudo mkdir /etc/ansible
$ sudo cp ~/ansible/examples/hosts /etc/ansible/

PKG

$ sudo pkg install ansible

Homebrew

$ brew update
$ brew install ansible

Primer comando

Ya hemos instalado Ansible en nuestra distribución favorita, ahora vamos ejecutar nuestro primer comando desde la máquina central.

Lo primero que necesitamos es crear / modificar el fichero /etc/ansible/hosts donde vamos a indicar los distintos nodos sobre los cuales vamos a realizar las tareas automáticas. En nuestro caso, vamos a indicar el nodo que tenemos disponible para las pruebas:

[webserver]
192.168.101.104  

Una buena descripción sobre la configuración de nuestro fichero hosts se puede encontrar AQUÍ

Ahora debemos asegurarnos de disponer una autenticación por llave SSH con el nodo. Para esto abrimos una consola en la máquina central y ejecutamos el comando:

$ ssh-keygen

Una vez finalizado el proceso de generación disponemos de 2 ficheros: ~/.ssh/id_rsa y ~/.ssh/id_rsa.pub

Copiamos la llave pública al nodo:

$ ssh-copy-id -i ~/.ssh/id_rsa.pub root@192.168.101.104

Ahora podemos iniciar una sesión SSH con el usuario root al nodo sin necesidad de una contraseña

Ya disponemos de todo lo necesario para ejecutar nuestro primer comando desde la máquina central

$ ansible all -m ping -u root

Si todo ha ido bien deberíamos poder obtener un mensaje similar a:

192.168.101.104 | success >> {  
    "changed": false, 
    "ping": "pong"
}

Si ejecutamos el mismo comando quitando el parámetro -u root nos encontrariamos con el error:

192.168.101.104 | FAILED => SSH encountered an unknown error during the connection. We recommend you re-run the command using -vvvv, which will enable SSH debugging output to help diagnose the issue  

Debido a que la conexión la hemos establecido para el usuario root y en caso de no especificar usuarios, Ansible va a utilizar el usuario actual.

PlayBook

Los Playbooks básicamente nos permiten gestionar la configuración del despliegue que vamos a realizar en los nodos. En ellos describimos la configuración, pero, también nos permiten orquestar una serie de pasos o tareas a seguir.

El Playbook se escribe utilizando YAML. Por ejemplo:

Veamos la composición del ejemplo:

Hosts and User

Para cada tarea se puede especificar el grupo de nodos objetivo y el usuario remoto que ejecutará cada operación.

---
- hosts: webservers
  remote_user: root

En caso de requerir distintos usuarios por tarea se puede especificar de la siguiente forma:

---
- hosts: webservers
  remote_user: root
  tasks:
    - name: test connection
      ping:
      remote_user: yourname

'sudo' está soportado

---
- hosts: webservers
  remote_user: yourname
  sudo: yes

Tasks

Las tareas son ejecutadas en orden, una a la vez, contra los nodos descritos en la sección hosts. Es importante destacar que si algún nodo falla en la ejecución de la tarea, este será sacado de la lista.

El objetivo de cada tarea es ejecutar un módulo. Los módulos sólo se ejcutarán cuando tengan algo que modificar. Si ejecutamos el Playbook una y otra vez, podemos estar seguros de que sólo cuando haya algo que modificar el módulo será ejecutado.

Los módulos command y shell sí serán ejecutados continuamente. Afortunadamente contamos con un check llamado creates que indicará que sólo debe ejecutarse si hay algo que modificar en la tarea.

Cada tarea debe contar con un 'name' que será incluido en la traza de salida de la operación. Por ejemplo:

tasks:  
  - name: make sure apache is running
    service: name=httpd state=running

'notify' son las acciones que se ejecutarán al final de cada tarea en el Playbook. Sólo serán ejecutadas una vez, incluso cuando sean llamadas por diferentes tareas. Por ejemplo: Muchas tareas pueden solicitar el reinicio de algún servicio específico, pero este sólo será reiniciado una sola vez.

notify:  
     - restart apache

Ejecución de un Playbook

Para ejecutar un Playbook desde la máquina central ejecutamos el comando:

$ ansible-playbook playbook.yml

Demo

Para la demo vamos a crear un Playbook llamado webserver.yml, con el que vamos a instalar las herramientas necesarias para publicar una página web. Lo primero que hacemos es crear nuestro Playbook en la máquina central con el siguiente contenido:

---
- hosts: webserver
  user: root

  tasks:
    ##
    # Instalación de paquetes necesarios.
    ##
    - name: General | Instalación de paquetes requeridos.
      action: apt pkg={{ item }} state=installed
      with_items:
        - php5
        - apache2
        - mysql-server
        - mysql-client
        - php5-mysql
        - php-apc
        - php5-xmlrpc
        - php-soap
        - php5-gd
        - unzip
        - python-mysqldb

    ##
    # Configuración de Apache2.
    ##
    - name: Apache2 | Habilitar módulos
      action: command a2enmod rewrite vhost_alias

    ##
    # Reinicio de servicios
    ##
    - name: Restart Apache
      action: service name=apache2 state=restarted

Básicamente indicamos que la primera tarea a ejecutarse es la instalación de las aplicaciones necesarias: php5, apache2, mysql, etc...

En la segunda tarea vamos a ejecutar un comando que habilita el módulo rewrite de nuestro Apache.

Por último reiniciamos el servicio del Apache.

El Playbook se va a ejecutar en todos los nodos que pertenezcan al grupo webservice declarado previamente en el fichero /etc/ansible/hosts. En nuestro caso es el nodo con la IP 192.168.101.104.

Vamos a ejecutar el Playbook utilizando el comando:

$ ansible-playbook webserver.yml

Una vez finalizado obtendremos un mensaje similar a:

PLAY [webserver] ************************************************************** 

GATHERING FACTS ***************************************************************  
ok: [192.168.101.104]

TASK: [General | Instalación de paquetes requeridos.] ************************  
changed: [192.168.101.104] => (item=php5,apache2,mysql-server,mysql-client,php5-mysql,php-apc,php5-xmlrpc,php-soap,php5-gd,unzip,python-mysqldb)

TASK: [Apache2 | Habilitar modulos] *******************************************  
changed: [192.168.101.104]

TASK: [Restart Apache] ********************************************************  
changed: [192.168.101.104]

PLAY RECAP ********************************************************************  
192.168.101.104            : ok=4    changed=3    unreachable=0    failed=0  

Podemos observar cómo al final se describe el resultado de la operación. Ok=4 y failed=0. Lo cual indica que todo se ha realizado sin ningún problema.

Así concluye esta pequeña guía sobre los primeros pasos con Ansible. En el siguiente post profundizaremos un poco más en la ejecución de módulos y tareas más complejas de configuración y despliegue de aplicaciones.

¿Qué te ha parecido? Espero que haya servido para aclarar dudas y conceptos básicos sobre la herramienta.