Soy Oscar Mas y en este post, me gustaría enseñaros que es AWX y como funciona.

AWX es una interfaz web para poder administrar nuestros roles que hemos creado en Ansible. Durante este post veremos como instalar AWX en un equipo mediante Docker y posteriormente como lanzar nuestros roles contras un equipo basado en Windows y otro basado en Linux.

Como ya es habitual, RedHat nos tiene acostumbrados a tener dos vertientes del mismo producto: uno comercial y el otro gratuito. Al igual que Ovirt es el mismo producto que RHEV (RedHat Enterprise Virtualization), AWX es su producto OpenSource y su correspondiente producto comercial es Ansible Tower.

Antes de continuar con el post, doy por hecho que tenéis conocimientos en los siguientes productos:

• Docker
• Ansible
• Git

Uno de los puntos que diferencia Ansible de sus competidores, como puede ser Chef o Puppet, es la posibilidad de volver a la versión anterior a consecuencia de algún error. Al no tener esta posibilidad de rollback en el código, Ansible otorga esa tarea a Git. Es por este motivo que AWX funciona con Git, ya sea en local o en la nube.

El esquema lógico sería el siguiente:

Lo que haremos en este post, es lanzar varios playbook desde AWX contra dos equipos. En el primer playbook crearemos un directorio en un servidor de Windows y en el segundo playbook copiaremos nuestro fichero de hosts en un servidor de Linux. De esta manera podremos ver el proceso de configuración en dos sistemas operativos diferentes.

Para poder desarrollar correctamente el laboratorio, necesitaremos los siguientes equipos:

• Un Domain Controller: Nos servirá de DNS para todos los equipos de nuestra red y el equipo basado en Windows estará metido en este dominio
• Un servidor de Linux para poder desplegar AWX, en el cual instalaremos también instalaremos Ansible.
• Dos equipos clientes: uno basado en Windows, el cual ha de estar en dominio y otro basado en Linux
• Una cuenta en GitHub o tener un Git desplegado en nuestra red

Puntos que no entran en este post, pero si lo veis interesante dejar un comentario:

• No he querido usar los inventarios dinámicos para no complicar el post, pero si no los conocéis, os aconsejo que les echéis un vistazo.
• Tampoco he usado “Encuestas” en AWX para el despliegue de los servidores. Todas las variables serán estáticas.
• No explico cómo cambiar los logos de nuestro AWX
• No explico cómo tunear AWX, para optimizar el rendimiento
• No explico los grupos de instancias para poder lanzar procesos de AWX en multiples servidores

Instalación de AWX

Antes de empezar con la instalación de AWX en nuestro equipo Linux, necesitaremos verificar que al menos tiene un par de cores (yo os aconsejo 4 Cores) y 4GB de RAM asignados a nuestro equipo virtual. Esto es a consecuencia de que cuando desplegamos AWX, no solamente se desplegamos un equipo en docker, sino que desplegamos varios equipos los cuales cada uno tiene una funcionalidad determinada para el correcto funcionamiento de AWX

El esquema lógico será el siguiente:

Lo primero que haremos es actualizar nuestros repositorios e instalar docker en nuestro equipo, junto con pip. Posteriormente instalaremos el módulo de docker mediante pip de la siguiente forma:

root@ansible:~# apt-get update && apt-get install -y docker docker.io git python-pip
root@ansible:~# pip install docker

Crearemos un directorio en el cual clonaremos mediante git los repositorios que nos servirán para desplegar los equipos necesarios

root@ansible:~# mkdir awx-install && cd awx-install
root@ansible:~/awx-install# git clone https://github.com/ansible/awx.git
root@ansible:~/awx-install# git clone https://github.com/ansible/awx-logos.git

En este fichero, definiremos las configuraciones de los diferentes servidores que se crearan cuando en el siguiente paso lancemos el playbook.

root@ansible:~/awx-install# vim awx/installer/inventory
postgres_data_dir=/var/lib/awx/pgdocker
default_admin_user=admin
default_admin_password=superpassword
awx_container_search_domains=ilba.cat
awx_alternate_dns_servers="172.26.0.10"
project_data_dir=/var/lib/awx/projects

Lanzaremos el playbook, el cual desplegará todos los servidores necesarios para su correcto funcionamiento:

root@ansible:~/awx-install# ansible-playbook -i awx/installer/inventory awx/installer/install.yml

Una vez acabado de lanzar el playbook que nos hemos descargado, ya podremos acceder al entorno web de AWX. EL usuario y contraseña para poder acceder a la administración web de AWX, recordar que se la hemos configurado en el fichero: inventory, antes de lanzar el playbook.

Como os he comentado con anterioridad, cuando desplegamos AWX, no solamente desplegamos un contenedor con AWX, sino que desplegamos una serie de contenedores para que AWX pueda funciona correctamente, como puede ser el entorno Web, la Base de Datos, etc… para poder ver los contenedores que hemos desplegado, lo podremos hacer con el siguiente comando:

Playbook para Windows

La intención de este post no es la de enseñaros PowerShell, así que realizaré un script muy sencillo que cree un directorio en la c:\ del servidor de destino. Para ello crearemos la estructura de directorios mediante el comando ansible-galaxy de la siguiente forma:

root@ansible:~# mkdir test-awx-powershell
root@ansible:~# cd test-awx-powershell
root@ansible:~/test-awx-powershell# ansible-galaxy init powershell

Los scripts en powershell los suelo sacar del directorio del role, así los puedo reusar en otros roles. Por eso veréis que el script está en el directorio: shared-files

root@ansible:~/test-awx-powershell# cat shared-files/directorio_pepe.ps1
$carpeta = $args[0]
mkdir C:\$carpeta

root@ansible:~/test-awx-powershell# cat powershell/tasks/main.yml
---
# tasks file for powershell
- name: Run powershell script
  script: shared-files/directorio_pepe.ps1 {{ nombre_directorio }}

root@ansible:~/test-awx-powershell# cat powershell/vars/main.yml
---
# vars file for powershell

nombre_directorio: "directorio_oscarmas"

Una vez creado nuestro rol lo subiremos a git para posteriormente poderlo usar desde AWX.

Procedimiento de AWX

La configuración de AWX, siempre sigue el mismo procedimiento para configurar nuestro playbook. A continuación os detallo los pasos a seguir durante la configuración de AWX:

1. Credenciales: Este punto de menú, es donde configuraremos las credenciales de acceso a los servidores de destino. Si es un servidor de Windows, añadiremos el usuario y la contraseña de acceso y si es un servidor de Linux añadiremos la clave SSH del servidor de destino y el usuario de acceso
2. Proyectos: Desde este punto de menú le indicaremos donde está ubicado nuestro proyecto de Ansible, en concreto nosotros usaremos Git.
3. Inventario: En este apartado le indicaremos los equipos y como conectarse a ellos.
4. Plantilla: Este es el apartado es donde mezclaremos las credenciales, proyectos e inventario. De esta forma configuraremos todos los datos para posteriormente poder lanzar nuestro Playbook
5. Lanzar plantilla: Simplemente desde este punto de menú, que es el mismo que el punto 4, lanzaremos nuestro proyecto.

Ahora que ya tenemos el procedimiento a seguir, empecemos con la configuración de AWX

Configuración de AWX para Windows

Recordar que tanto en AWX como Ansible, cuando lanzamos un playbook contra un sistema operativo basado en Windows, necesitamos que el servidor de destino tenga habilitado y configurado Winrm, ya que será por aquí por donde lanzará nuestro playbook. Si desconocéis como realizarlo, simplemente necesitáis la herramienta de SolarWinds o creando una política de Active Directory. Si queréis usar SolarWinds os dejo el enlace:

• http://www.solarwinds.com/free-tools/remote-execution-enabler-for-powershell

Una vez configurado WinRM, accederemos a la administración de AWX y le indicaremos las credenciales que nos permitirán acceder al servidor de destino:

Seguidamente crearemos nuestro Proyecto, el cual se descargará de Git el role que hemos creado con anterioridad. Acordaros que el role lo hemos subido anteriormente a Git.

Una vez creado nuestro inventario, haremos click en el icono de la nube, para que nuestro AWX se descargue el proyecto de nuestro role, el cual está ubicado en Git. También se puede realizar una actualización automática desde nuestro Git marcando la opción “Update Revision on Launch” en la captura anterior. Así cada vez que se lance el proyecto, revisará en Git que disponemos de la ultima versión de nuestro playbook.

Ahora configuraremos nuestro inventario y le indicaremos el host de destino. En nuestro caso será el servidor host2.ilba.cat, el cual en mi caso es un Hyper-V. En este punto, es importante destacar que le hemos indicado en las variables que se conecte al servidor mediante Winrm y el puerto que usamos.

Como he indicado anteriormente no usaremos inventarios dinámicos, así que tendremos que crear nuestro host a mano:

Ahora todas las configuraciones que hemos hecho con anterioridad las enlazaremos todas desde la plantilla:

Como indiqué al principio del post, no usaremos la opción “Añadir Encuesta”. En la cual podremos añadir el nombre de la variable ( en nuestro caso el nombre del directorio ) y al lanzarlo nos solicitará dicha variable.

Una vez configurada nuestra plantilla, ya podremos lanzarla y ver el resultado:

Una vez lanzado, tendremos que esperar a que se ejecute y posteriormente podremos verificarlo

Playbook para Linux

En este Playbook, lo que haremos en copiar nuestro fichero de hosts al servidor de destino. Como os he comentado al principio del post, la finalidad no es aprender de Ansible, la finalidad es saber configurar de forma básica AWX.

Antes de empezar os recuerdo que Ansible se basa en Python, así que necesitaremos tener instalado en el servidor de destino el paquete: python-minimal.

También es necesario tener una clave SSH para poder acceder al servidor de destino sin necesidad de indicarle el password de acceso.

Lo que vamos a hacer en este playbook es copiar nuestro fichero de hosts en el directorio temporal del servidor de destino de Linux. Para ello primero crearemos la estructura de directorios de Ansible mediante el comando ansible-galaxy de la siguiente forma:

root@ansible:~# mkdir test-awx-copyfile
root@ansible:~# cd test-awx-copyfile
root@ansible:~/test-awx-copyfile# ansible-galaxy init copy_file

Posteriormente crearemos el playbook  que copiará nuestro fichero de hosts en el servidor de destino:

root@ansible:~/test-awx-copyfile# cat copy_file/tasks/main.yml
---
# tasks file for template
- name: copiando un fichero
  copy:
    src: /etc/hosts
    dest: /tmp/{{ nombre_fichero }}

root@ansible:~/test-awx-copyfile# cat copy_file/vars/main.yml
---
# vars file for template
nombre_fichero: "fichero_oscarmas"

Una vez acabado de configurar lo subiremos a nuestro Git, para posteriormente indicárselo a AWX.

Configuración de AWX para Linux

Lo primero que haremos es acceder a la administración de AWX y desde allí crearemos el acceso a nuestro servidor de Linux. En el apartado “SSH PRIVATE KEY” hemos de pegar nuestra clave SSH para poder acceder al servidor de destino y rellenar los campos tal y como se indica en la siguiente captura:

Seguidamente, en el punto de menú “PROYECTOS”, le indicaremos nuestro repositorio git de donde se descargará nuestro código del playbook:

Una vez grabado, acordaros de descargar de Git nuestro Playbook. También se puede realizar una actualización automática desde nuestro Git marcando la opción “Update Revision on Launch” en la captura anterior. Así cada vez que se lance el proyecto, revisará en Git que disponemos de la ultima versión de nuestro playbook.

Ahora solamente nos queda crear el equipo de destino en nuestro inventario, en mi caso el equipo de destino es: template.ilba.cat

Y ahora tendremos que unificar todos los pasos anteriores desde nuestra plantilla:

Una vez hecho los pasos anteriores, solamente nos queda lanzar nuestro playbook desde la consola de AWX:

Una vez lanzado nuestro playbook, podremos verificar que nos ha creado el fichero. Espero que os sirva de ayuda.