Puppet, SaltStack, Chef

1. ANÁLISIS COMPARATIVO DE
HERRAMIENTAS DE DEVOPS
Presentado por:
ü Carlos Escoto
ü Daniel Atuesta R.

2. 2
Tabla de contenido
1. INTRODUCCIÓN ................................................................................................................... 3
2. HERRAMIENTAS DEVOPS ..................................................................................................... 4
2.1. PUPPET ........................................................................................................................... 4
2.2 SALTSTACK ...................................................................................................................... 5
2.3. CHEF ............................................................................................................................... 6
3 ANÁLISIS COMPARATIVO DE LAS HERRAMIENTAS DEVOPS ................................................. 7
3.1 COMPATIBILIDAD CON SISTEMAS OPERATIVOS. .............................................................. 8
3.2 INTEGRACIÓN CON OTRAS PLATAFORMAS/HERRAMIENTAS ........................................... 8
3.3 RENDIMIENTO DE LAS HERRAMIENTAS ........................................................................... 9
3.4 SEGURIDAD DE LAS HERRAMIENTAS ............................................................................. 10
4 DESPLIEGUE DE LAS HERRAMIENTAS DEVOPS ................................................................... 11
4.1 PUPPET ......................................................................................................................... 11
4.2 SALTSTACK .................................................................................................................... 15
4.3 CHEF ............................................................................................................................. 16
5 CONCLUSIONES ................................................................................................................. 22
6 BIBLIOGRAFÍA ................................................................................................................... 24

3. 3
1. Introducción
En la actualidad, gran parte de las operaciones de las empresas se basa en sistemas de
software, hardware y comunicaciones, dependiendo del tipo de actividad al que se dedique
una empresa. Teniendo en cuenta eso, los administradores de redes y sistemas deben
afrontar el crecimiento de la infraestructura tecnológica el cual puede ser un problema. En
este contexto es esencial que el esquema de la infraestructura tecnológica de cada empresa
sea escalable y además permita aplicar estándares los cuales faciliten la gestión de esta
misma.
Las empresas que están distribuidas en diferentes países y regiones del mundo, deben
considerar esto como un factor relevante, considerando las necesidades de rendimiento,
capacidad y disponibilidad de respuesta, además del crecimiento de las operaciones sin
necesidad de realizar cambios los cuales puedan repercutir en el funcionamiento de la
empresa. Una difícil tarea es implementar las herramientas apropiadas, decidir cual
herramienta se debe usar teniendo en cuenta las características de la infraestructura,
además de la identificación del problema en particular que se tiene. Por lo tanto en este
trabajo, se analizaran diferentes herramientas que puedan permitir a una empresa
reaccionar ante las fuerzas del mercado de forma confiable y eficiente.

4. 4
2. Herramientas DevOps
DevOps es el acrónimo en inglés de Development Operations (Desarrollo y Operaciones)
herramientas para administrar infraestructuras, nacen a partir de la expansión de las
operaciones de los negocios en diferentes partes del mundo, para esto se crearon
diferentes herramientas las cuales ofrecen apoyo a la administración y configuración de
infraestructuras de forma centralizada.
En el presente trabajo, analizaremos tres de ellas.
2.1. Puppet
Esta herramienta, fue creada con el fin de facilitar las diferentes operaciones de tecnologías
de información, optimizando procesos de configuración de forma práctica y rápida,
automatizando tareas repetitivas, contando con características como el ajuste a
infraestructuras escalables, contando con una gestión por medio de interfaz gráfica (web)
o terminal. La configuración de las maquinas pueden ser establecida por medio de código,
escribiéndolas en lenguaje propio de Puppet. Gracias a esto las relaciones entre los recursos
y la configuración están escritas en código por lo que facilita no solo saber la configuración
en si, sino que también el porqué de alguna configuración en específico, lo cual ayuda a
mejorar el proceso de continua integración consiguiendo desarrollar y probar aplicaciones
desplegadas con la misma configuración del sistema.
Es una herramienta que se integra con herramientas de entornos en la nube como, Amazon
Web Service las cuales marcan una tendencia.
La arquitectura que emplea Puppet es “Cliente-Servidor”, la empresa creadora de esta
herramienta (Puppet Labs.) la denominan arquitectura “Master-Agent”. Master hace
referencia al servidor central el cual contiene el núcleo de las funciones de configuración
(Recursos). El cliente, en este caso “Agent” le corresponde gestionar los diferentes procesos
en los nodos remotos. Este tipo de arquitectura esta creada para usarse como un servicio
que ejecuta en cada nodo. Esta herramienta tiene una variante la cual es denominada
“Puppet Apply” la cual usa una metodología orientada a soluciones en la nube, esta variante
tiene la característica de velocidad, ya que no requiere validación concreta de la ejecución,
esto sin afectar los niveles de seguridad, ya que encapsula los recursos que se ejecutan por
los diferentes nodos remotos.
Puppet cuenta con dos versiones:
⇒ Puppet Open Source: Esta versión está enfocada y diseñada para brindar soluciones
a infraestructuras pequeñas las cuales no demandan grandes procesos, son
sostenibles y de bajo costo.

5. 5
⇒ Puppete Enterprise: Esta es una versión que ofrece soluciones para solucionar
problemas de integración en infraestructuras de topología compleja, además de
contar con soporte de parte de los desarrolladores (Puppet Labs).
Debido a que esta es una herramienta muy completa, requiere un aprendizaje amplio, con
tiempo de dedicación, conocimientos técnicos en redes, programación e infraestructuras
en general.
2.2 SaltStack
SaltStack es una herramienta desarrollada con el objetivo de administrar sistemas de
información integrados por muchos dispositivos de forma más fácil. Esta herramienta está
bajo licencia Apache y utiliza Python como lenguaje de programación para la gestión de
configuración.
Las soluciones de automatización que ofrece SaltStack son para los siguientes tipos de
clientes:
⇒ Operadores de Tecnologías de Información: Esta herramienta se encarga de la
administración de las arquitecturas compuestas por muchos dispositivos.
⇒ DevOps: SaltStack ofrece soluciones a la medida, las cuales ofrecen soluciones de
gestión óptima.
⇒ Operadores de Nube (CloudOps): Esta herramienta puede adaptarse a las
tendencias que ofrecen los proveedores de cloud.
SlatStack cuenta con características principales como:
⇒ Flexibilidad: Esta herramienta puede ser adaptada a diferentes arquitecturas y
modelos de desarrollo empresarial, desde una red de topología sencilla hasta
soluciones para centros de procesos de datos.
⇒ Velocidad: SaltStack ofrece soluciones de gestión de forma fácil y eficaz a bajo coste.
⇒ Escalabilidad: SaltStack tiene la capacidad de soporte y crecimiento en múltiples
plataformas, para gestionar fácilmente.
Al igual que la anterior herramienta (Puppete), SaltStack trabaja bajo el modelo “Cliente-
Servidor”, en donde el servidor se denomina “Master” y los nodos “Minions”. Los nodos son
gestionados por medio de líneas de comando donde se interpretan y generan soluciones de
administración de dispositivos remotos.

6. 6
El servidor o “Master” como es denominado en este caso, identifica los nodos “Minions”
por medio de una etiqueta de identificación única, la cual es transportada por medio de un
protocolo intérprete de red seguro “Secure Shell”.
2.3. Chef
Chef es una herramienta que inicialmente fue desarrollada con el objetivo de solucionar la
problemática de gestión en los centros de procesos de datos de Amazon y Microsoft, pero
fue actualizada y evoluciono para abarcar distintas plataformas.
Chef gestiona los procesos en los nodos y en las estaciones de trabajo usando lenguajes de
programación Erlang1
y Ruby2
. Actualmente Chef se caracteriza por ser multiplataforma
además de ser escalable y flexible, ofrece más seguridad que otras herramientas del
mercado.
La característica más importante de esta herramienta es que se desarrolló para la gestión
de entornos virtuales, lo cual hace más fácil la escalabilidad a ambientes cloud, además Chef
tiene una excelente integración con OpenStack, Google Compute Engine, Windows Azure y
Amazon Web Service.
Gracias a la excelente adaptación en diferentes escenarios, cuenta con clientes importantes
como LinkedIn, Facebook o Youtube, entre otros.
Chef está compuesto por servidor de gestión “Chef Server”, Estaciones de trabajo
“Workstation” las cuales están dedicadas a interactuar con “Chef Server” y con los nodos,
lo que quiere decir que es el intermediario entre los nodos y el servidor central.
Cuando se habla de nodos se hace referencia a los elementos que componen la
infraestructura tecnológica.
Los componentes de esta herramienta están estructurados de forma jerárquica, los cuales
son gestionados a través de “Chef Cookbooks” la cual es una unidad de configuración donde
son gestionadas las estaciones de trabajo (Workstation).
Existen diferentes tipos de Chef Server:
⇒ Open Source Chef Server: Esta es la versión gratis, la cual es usada por pequeñas
empresas ya que es de código abierto y permite gestionar diferentes módulos de la
herramienta, claro está que con ciertas limitaciones.
⇒ Hosted Chef Server: Esta versión de servidor es la principal herramienta de uso
comercial, gracias a que ofrece soluciones a distintos problemas de forma
predeterminada haciendo uso de módulos existentes en los repositorios.
1
Lenguaje de programación concurrente.
2
Lenguaje de programación orientado a objetos.

7. 7
⇒ Private Chef: Esta herramienta cuenta con la característica de ajustarse a las
necesidades específicas de los clientes.
Además los nodos también están clasificados:
⇒ Nodos virtuales: Dispositivos virtuales.
⇒ Nodos instancias de Cloud: Componentes que se encuentran en entorno cloud.
⇒ Nodos físicos: Cualquier dispositivo físico, estaciones de trabajo, tablet’s,
enrutadores, entre otros.
3 Análisis comparativo de las herramientas DevOps
Perspectiva general de cada una de las herramientas:
Propiedades Puppet SaltStack Chef
Tipo de licencia GNU GPL y Apache Apache Apache
Arquitectura Cloud y Cliente-Servidor Cloud Cloud y Cliente-Servidor
Lenguaje Ruby Python Ruby
Escalable Si Si Si
Encriptación Si Si Si
Multiplataforma Si Si Si
Tabla 1: Características.
Estas herramientas poseen características similares, que son desarrolladas bajo licencia de
software libre, lo cual permite modificar y distribuirlas bajo ciertos criterios, lo que permiten
al usuario final tener libertad de uso. Cada una de las herramientas mencionadas tiene su
repositorio de código fuente en línea y de acceso público con el fin de que los usuarios
tengan la opción de modificarlas a su criterio y necesidades.
SaltStack tiene arquitectura Cloud, para optimizar los tiempos de administración y
ejecución. Por tal motivo Puppet y Chef debieron evolucionar ya que estas dos herramientas
tiene arquitectura con el modelo Cliente-Servidor.
Estas herramientas poseen un conjunto de librerías denominadas módulos, los cuales
gestionan la infraestructura. Cada librería gestiona los módulos de distinta forma incluso
integrando módulos de una herramienta en otra, teniendo en cuenta que el lenguaje de
programación en el que está desarrollado sea el mismo.
Por ejemplo Puppet puede integrar módulos de Chef que estén desarrollados en lenguaje
Ruby, tan solo con descargar el código fuente de las herramientas.
Funciones principales que gestionan los módulos:
⇒ Administración de archivos.
⇒ Administración y configuración de sistemas.

8. 8
⇒ Administración de servicios.
⇒ Administración y configuración de backup’s.
3.1 Compatibilidad con Sistemas Operativos.
Hoy en dia las empresas u organizaciones, hacen uso de diferentes dispositivos como
servidores, equipos de trabajo, dispositivos móviles, entre otros, los cuales resultan
complejos de administrar en una red empresarial asociada a una tecnología específica. Por
tal motivo las herramientas deben ser compatibles con todos los sistemas operativos que
hay en el mercado.
Puppet, SaltStack y Chef desarrollan sus funciones en diferentes plataformas de sistemas
operativos. Por otro lado tienen la característica de poder administrar la infraestructura sin
importar el modelo de negocio y arquitectura de red de una empresa.
Plataformas soportadas por cada herramienta:
Sistema Operativo Puppet SaltStack Chef
Linux Si Si Si
OS X Parcial Si Si
Windows Si Si Si
Solaris Si Si Si
IBM AIX Si Si Si
Tabla 2: Compatibilidad Sistemas Operativos.
3.2 Integración con otras Plataformas/Herramientas
A partir de la necesidad de negocio, las herramientas DevOps, son capaces de integrarse
con otras herramientas para formar sistemas complejos.
Integrándose con servicios en la nube, para gestionar y administrar de forma automatizada
los procesos que conlleva una instancia, de tal forma que se faciliten las tareas, como por
ejemplo en un centro de proceso de datos. También administrar los procesos de una
máquina virtual, las copias de seguridad de las maquinas, gestionar los puertos de red
virtual que tienen los motores de virtualización, entre otros.
Plataformas/Herramientas Puppet SaltStack Chef
OpenStack Si Si Si
VMware Si Si Si
Team Foundation Server Si Si Si
Amazon Web Service Si Si Si
Google Compute Engine Si Si Si
Nagios Si Si Si
Tabla 3: Integración con otras Plataformas/Herramientas

9. 9
Este tipo de herramientas, permiten desarrollar tareas en otras áreas informáticas, como
por ejemplo en la gestión de repositorios de código, monitorio de redes, entre otros. Solo
con ejecutar el modulo respectivo, en caso que el modulo que requerido no exista, este
puede ser desarrollado con alguno de los lenguajes de programación soportados.
Estas herramientas integran en su propia arquitectura, diferentes módulos los cuales
permiten administrar y monitorear la infraestructura. Por ejemplo Amazon Web Service
(AWS) implementa módulos en las tres herramientas para integrar la gestión automatizada
de los procesos de red. Este tipo de integración permite el desarrollo de sistemas de
monitoreo, los cuales puede realizar procesos de configuración reduciendo la intervención
de los administradores de infraestructura.
3.3 Beneficio de las Herramientas
El beneficio de estas herramientas es un tema de gran relevancia, ya que al administrar
muchos dispositivos de forma simultanea requiere un buen rendimiento de ejecución.
Uno de los aspectos determinante en la velocidad de estas herramientas es el tipo de
arquitectura, ya que son más eficaces las arquitecturas basadas en servicios en la nube que
las arquitecturas Cliente-Servidor, esto gracias a que la arquitectura en la nube tiene
ejecución directa, lo que quiere decir que no necesitan de un Cliente para poder ejecutar
las tareas de configuración y administración en los nodos.
Puppet es una de las herramientas más completas y además compleja ya que ofrece dos
arquitecturas distintas (Nube y Cliente-Servidor) asimismo tiene dos modelos de ejecución,
lo cual la convierte en una herramienta con diferentes posibilidades de ejecución
ofreciendo soluciones a un mismo problema dependiendo de lo que se requiera.
Puppet es una de las herramientas DevOps optimizada más reconocida, gracias a los
módulos que ofrece para diferentes procesos, los cuales son ejecutados con un rendimiento
que permite administrar de forma rápida muchos dispositivos.
Por otro lado SaltStack distribuye los procesos entre múltiples nodos, lo que permite
desplegar nodos centrales y así tener varias opciones para responder las peticiones que se
realizan a los “Minions”.
Chef optimiza los procesos gracias a la implementación de estaciones de trabajo
“Workstations”, estos procesos contienen repositorios de Chef los cuales ejecutan tareas y
se utilizan como “Chef Servers” mejorando los procesos de ejecución y administración de
tareas a fragmentos de una infraestructura tecnológica.
El rendimiento de las tres herramientas es parecido, ya que pueden ser de uso específico o
de uso general, dependiendo de las necesidades del usuario. Lo que se debe tener en cuenta
en este caso es la antigüedad o trayectoria, ya que entre más trayectoria pueden tener más
módulos afinados.

10. 10
3.4 Seguridad de las Herramientas
Uno de los aspectos más significativos en la elección de cualquier tipo de herramienta en
general es la seguridad. Los usuarios buscan altos estándares de seguridad los cuales
garanticen la efectividad de los procesos realizados.
Puppet implementa complementos de seguridad:
⇒ Seguridad ActiveMQ: Tanto los dispositivos intermedios como el servidor central
usan protocolos de seguridad para la autenticación de cada uno de los nodos.
⇒ SSL: Para la generación de conexiones SSH3
seguras, usando certificados públicos y
privados.
⇒ AES+RSA de seguridad: Certifica la seguridad de las estructuras Puppet haciendo
uso de claves públicas y privadas.
Proceso de Puppet para ejecuciones y conexiones seguras por medio de redes.
I. Conexión del cliente por medio de credenciales.
II. Conexión con el Middleware de red.
III. Autenticación de red.
IV. Conexión a los nodos por medio de credenciales.
V. Autorización simple RPC4
.
VI. Auditoria RPC.
Tabla 4: Proceso de autenticación en Puppet
Por otro lado SaltStack usa una librería de seguridad, con complementos de criptografía de
lenguaje de programación PyCrypto (Python), este complemento realiza sus funciones
gracias al intercambio de llaves numéricas entre el cliente y el nodo principal, el cual
interpreta ordenes seguras que no requieren de agentes en los nodos cliente. En
consecuencia su rendimiento se ve afectado ya que disminuye el rendimiento en las
comunicaciones debido al consumo de recursos.
Chef opera de forma similar a Puppet, ya que usa certificados de seguridad de la capa de
transporte (SSL)5
para establecer conexión segura entre el servidor Chef y los nodos Chef.
El cliente Chef denominado “Knife” realiza los procesos de generación y lectura de las llaves
públicas y privadas.
Chef usa medidas de seguridad que brindan confianza en la manipulación de los datos y
agrega una capa externa de seguridad a las arquitecturas de red.
3
SSH: Secure Shell, es un protocolo el cual sirve para acceder a maquinas remotas por medio de una red.
4
Remote Procedure Call, protocolo de red que permite a un programa ejecutar código en otra máquina remota.
5
SSL (Secure Sockets Layer): Protocolos criptográficos que proporcionan comunicaciones seguras por una red.

11. 11
4 Despliegue de las herramientas DevOps
Ahora vamos a proceder a realizar el despliegue o la instalación de las herramientas que
hemos escogido: Puppet, SaltStack y Chef. Una vez realizada la explicación de esta
instalación, realizaremos una receta con cada una. Todos los despliegues los vamos a
realizar en el sistema operativo Ubuntu.
4.1 Puppet
En primer lugar, para realizar la instalación de Puppet vamos a tener que realizar la
instalación de puppetmaster. Ejecutamos el siguiente comando:
apt-get install puppetmaster
Una vez instalado, configuramos el directorio donde se pondrán los ficheros. Así, abrimos
el fichero fileserver.conf.
editor /etc/puppet/fileserver.conf
En este caso, como nuestras máquinas están en el mismo rango, las IP tendrán una
terminación0/24 y el fichero quedará así:
[files]
path /etc/puppet/files
allow 192.168.122.0/24
[plugins]
allow 192.168.122.0/24
Ahora vamos a crear ficheros para los nodos de la siguiente forma:
node pruebanode {
}
node 'client1.cluster' inherits pruebanode {
}
node 'client2.cluster' inherits pruebanode {
}

12. 12
Si este fichero quiere tenerse en cuenta, hay que crear el fichero
/etf/puppet/manifests/site.pp e incluer el fichero que hemos creado también. El contenido
que nosotros tenemos en este fichero es el siguiente:
Import “nodes”
Ahora lo reiniciamos:
service puppetmaster restart
Ahora realizamos la instalación del paquete puppet para que podamos controlarlo desde la
máquina:
apt-get install puppet
Revisamos el fchero de configuración del cliente, que debería ser el siguiente:
root@client1:~# cat /etc/puppet/puppet.conf
[main]
logdir=/var/log/puppet
vardir=/var/lib/puppet
ssldir=/var/lib/puppet/ssl
rundir=/var/run/puppet
factpath=$vardir/lib/facter
templatedir=$confdir/templates
[agent]
server=master.cluster
Para que funcione puppetd tenemos que habilitar el dominio de la siguiente forma editando
el fichero etc/default/puppet:
editor /etc/default/puppet
Debe asegurarnos que está configurado como ‘yes’. Ahora arrancamos el servicio:
service puppet start

13. 13
Ahora vamos al máster y comprobamos que están bien registrados, en nuestro caso los dos
clientes:
root@master:~# puppet cert --list --all
client1.cluster (00:00:ssl_fingerprint:00:00)
client2.cluster (00:00:ssl_fingerprint:00:00)
+ master.cluster (00:00:ssl_fingerprint:00:00)
Y por último, firmamos los certificados de los clientes:
root@master:~# puppet cert --list
client2.cluster
client1.cluster
root@master:~# puppet cert --sign client1.cluster
notice: Signed certificate request for client1.cluster
notice: Removing file Puppet::SSL::CertificateRequest client1.cluster at '/var/l
ib/puppet/ssl/ca/requests/client1.cluster.pem'
root@master:~# puppet cert --sign client2.cluster
notice: Signed certificate request for client2.cluster
notice: Removing file Puppet::SSL::CertificateRequest client2.cluster at '/var/l
ib/puppet/ssl/ca/requests/client2.cluster.pem'
Ahoa vamos a asignar los módulos, que es donde definiremos las configuraciones y los
ficheros. Creamos la estructura básica:
mkdir -p /etc/puppet/modules/prueba/{manifests,files,templates}
Creamos un fichero vacío donde pondremos la receta de puppet.
touch /etc/puppet/modules/prueba/manifests/init.pp
Ahora editamos este fichero mediante para que tenga este aspect:
node pruebanode {
include prueba
}
node 'client1.cluster' inherits pruebanode {

14. 14
}
node 'client2.cluster' inherits pruebanode {
}
Ahora ya tendremos un módulo asignado a cada uno de los clientes.
Por último, vamos a realizar una prueba mediante una receta. Colocaremos un fichero en
la ruta /etc/puppet/prueba/files llamado “ficherodeprueba” que contiene la frase “esto es
un fichero de prueba”. Nos dirigiremos a /etc/puppet/module/prueba/manifests/init.pp y
ponemos el siguiente contenido:
class prueba {
file { "/root/ficherodeprueba":
owner => root,
group => root,
mode => 400,
source => "puppet:///modules/prueba/ficherodeprueba",
}
}
Ahora, comprobamos que ha funcionado y tenemos nuestro fichero ejecutando en el
cliente lo siguiente:
root@client1:~# puppetd -vt && ls
info: Caching catalog for client1.cluster
info: Applying configuration version '1322082679'
notice: Finished catalog run in 0.05 seconds
ficherodeprueba

15. 15
4.2 SaltStack
Para realizar la instalación de SaltStack tenemos que añadir el paquete de SaltStack a
nuestro repositorio:
sudo apt-get install python-software-properties
sudo add-apt-repository ppa:saltstack/salt
Ahora tendremos que actualizar nuestra base de datos de apt:
Sudo apt-get update
Una vez añadido el paquete, podremos instalar Salt Master y Salt Minion. Para ello
ejecutamos lo siguiente:
sudo apt-get install salt-master
sudo apt-get install salt-minion
Lo siguiente será enseñarle a Salt Minion a encontrar Salt Master.Nosotros lo tendremos en
el mismo host por lo que le indicaremos en las opciones de configuración que está en
“localhost”. Así que editamos el fichero “minion”:
vi /etc/salt/minion
Y así, en la línea que hace referencia al master le indicamos el valor “localhost”
master: localhost
Una vez realizado el cambio reininciamos Salt Minion:
service salt-minion restart
Ponemos la lista de las claves Minion que conoce el Master:
Salt key -L

16. 16
Se deberían mostrar las claves de la siguiente forma bajo el texto “Unaccepted keys”:
Accepted Keys:
Unaccepted Keys:
Carlosydani
Rejected Keys:
Por ultimo, tenemos que hacer que el Master acepte las claves de Minion, y para ello
debemos ejecutar lo siguiente:
Salt –key –a ‘Carlosydani’
Y deberíamos ver lo siguiente:
The following keys are going to be accepted:
Unaccepted Keys:
Carlosydani
Proceed [n/Y] y
Key for minion Carlosydani accepted
Con estos pasos ya tendremos funcionando en Ubuntu Salt Master y Salt Minion.
4.3 Chef
Para realizar la instalación de Chef en nuestro sistema debemos tener un servidor DNS para
que se puedan comunicar el servidor y el cliente. Si no disponemos de uno debemos
añadirlo mediante el siguiente comando:
127.0.0.1 chef-client.example.com chef-client
192.168.2.15 server.example.com server
# The following lines are desirable for IPv6 capable hosts
::1 ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes

17. 17
ff02::2 ip6-allrouters
Ahora comprobamos que lo hemos configurado correctamente mediante el comando
“hostname-f”:
root@chef-client:~# hostname -f
chef-client.example.com
Ya está todo listo para comenzar a instalar Chef.
Hay varias opciones para instalar Chef-Server, pero nosotros usaremos un repositorio de
Opscode para instalarlo desde ahí. En primer lugar, añadimos los repositorios:
root@server:~# echo "deb http://apt.opscode.com/ `lsb_release -cs`-0.10 main" |
sudo tee /etc/apt/sources.list.d/opscode.list
Ahora ponemos la clave GPD de Opscode para apt:
mkdir -p /etc/apt/trusted.gpg.d
gpg --keyserver keys.gnupg.net --recv-keys 83EF826A
gpg --export packages@opscode.com | sudo tee /etc/apt/trusted.gpg.d/opscode-keyr
ing.gpg > /dev/null
Actualizamos y a continuación instalamos el paquete “opscode-keyring” para mantener la
clave actualizada y ejecutamos el upgrade:
apt-get update
apt-get install opscode-keyring # permanent upgradeable keyring
apt-get upgrade
Ahora instalamos Chef-Server desde los repositorios:
apt-get install chef chef-server
Tendremos que poner contraseñas para Chef-solr y algunas configuraciones más. Nos saldrá
un error a la hora de inciar pero una vez finalizada podremos iniciarlo bien:
/etc/init.d/chef-server start

18. 18
Ahora tenemos que comprobar los puertos para ver que lo hemos instalado todo bien:
netstat -putan
Los puertos que debemos comprobar serán el 4000 (Chef-Server), 4040 (Chef-Server-
Webui), 5984 (CouchDB), 5672 (RabbitMQ) y 8983 (Chef-Solr).
Con esto habremos finalizado la instalación de Chef- Server, pero debemos de configurar
nuestra WorkStation. La configuraremos en el mismo servidor, aunque podría ser en otro
equipo independiente.
Creamos el directorio “.chef” y creamos los certificados necesarios:
mkdir -p ~/.chef
sudo cp /etc/chef/validation.pem /etc/chef/webui.pem ~/.chef
Ponemos nuestro usuario como propietario:
sudo chown -R $USER ~/.chef
Y por último creamos la api con los siguientes comandos:
usuario@server:~$ knife configure -i
Overwrite /home/usuario/.chef/knife.rb? (Y/N) Y
Please enter the chef server URL: [http://server.example.com:4000]
Please enter a clientname for the new client: [usuario]
Please enter the existing admin clientname: [chef-webui]
Please enter the location of the existing admin client's private key: [/etc/chef
/webui.pem] .chef/webui.pem
Please enter the validation clientname: [chef-validator]
Please enter the location of the validation key: [/etc/chef/validation.pem] .che
f/validation.pem
Please enter the path to a chef repository (or leave blank):
Creating initial API user...
Created client[usuario]
Configuration file written to /home/usuario/.chef/knife.rb

19. 19
De esta forma ya podremos accede a nuestra interfaz web mediante la ip y el puerto 4040
(http:/ipservidor:4040). Nos pedirá el usuario y contraseña que pusimos y ya está listo.
Ahora debemos crear en el cliente el directorio ‘/etc/chef’ para guardar tanto la
configuración como la clave necesaria para conectarse a Chef-Server.
mkdir -p /etc/chef
A continuación, vamos al servidor y creamos el archivo para configurar Chef y su clave.
knife configure client ./
Una vez que los hemos creado ambos, pasaremos a copiar los dos archivos:
scp root@192.168.2.15:/root/client.rb /etc/chef/
scp root@192.168.2.15:/root/validation.pem /etc/chef/
La dirección IP tiene que ser la correspondiente a la de nuestro servidor.
Ahora comprobaremos que lo hemos indicado todo adecuadamente en el fichero ‘client.rb’.
og_level :info
log_location STDOUT
chef_server_url 'http://server.example.com:4000'
validation_client_name 'chef-validator'
Ahora solo tenemos que reiniciar Chef-Client:
service chef-client restart
Si comprobamos, veremos que nos aparece nuestro nuevo nodo creado:
root@server:~# knife node list
chef-client.example.com
server.example.com

20. 20
Así mismo, también podremos comprobarlo en la interfaz web:
Ahora realizaremos nuestra primera receta en Chef. Para gestionar las recetas nosotros
utilizaremos Knife. Le indicaremos la siguiente línea en el fichero ‘knife.rb’ que hay en el
directorio .chef:
cookbook_path ['/root/chef-repo/cookbooks' ]
Ahora ya lo tenemos listo para crear la receta. Ejecutamos el siguiente comando con el
nombre de nuestra receta:
knife cookbook create recetaApache
Así, se nos creará un nuevo directorio “cookbooks” con el siguiente contenido:
root@server:~# ls chef-repo/cookbooks/recetaApache/
attributes definitions libraries providers recipes templates
CHANGELOG.md files metadata.rb README.md resources

21. 21
Ahora lo que haremos será modificar la receta ‘default.rb’ para que contenga lo siguiente:
package "apache2" do
action :install
end
template node['nodo1']['path'] + '/index.html' do
source 'index.html.erb'
mode 0755
owner 'root'
group 'root'
end
service "apache2" do
action :restart
end
Lo primero que hará es instalar el paquete ‘apache2’, le cambiará el fichero ‘index.html’ por
el ‘nodo1’, que es un atributo definido en el fichero ‘default.rb’ de la siguiente forma:
default["nodo1"]["path"] = "/var/www"
El ‘template’ que tenemos en la receta hace que sustituya el archivo ‘index.html’ por una
plantilla definida llamada ‘index.html.erb’ que contiene lo siguiente:
<html>
<h1>
Esta es mi primera receta
</h1>
</html>
Ahora actualizamos la receta al nodo en que queremos que se ejecute:
knife node run_list add chef-client.example.com 'recipe[recetaApache]'

22. 22
Y por último actualizamos:
knife cookbook upload -a
Ejecutamos el comando chef –client y entramos a la IP en el navegador:
5 Conclusiones
En la actualidad los negocios van a una “velocidad” en la que los modelos empresariales
existentes se han visto forzados a dinamizar y acelerar cambios e innovaciones.
Las herramientas DevOps proporcionan soluciones que unifican las operaciones con el
desarrollo de una empresa, lo cual contribuye a la aceleración en innovación para satisfacer
la demanda de mercado. Gracias a este tipo de herramientas el interactivo y rápido
desarrollo de estas hace que las empresas puedan reaccionar mejor para satisfacer las
necesidades de los clientes.
El uso de este tipo de herramientas se caracteriza por que tanto como los desarrolladores
como los operadores deben trabajar en equipo centrándose en el crecimiento de la
empresa.
Las herramientas DevOps comparadas en este trabajo, son de código abierto para la
automatización, gestión e integración continua de las empresas, utilizándose como
herramientas de entrega continua, facilitado cambios claves en las organizaciones,
trayendo beneficios como:
» Aumento en la rapidez de entrega: Este cambio consiste en conseguir mayor
capacidad de respuesta a la demanda empresarial con nuevas funcionalidades y
características.
» Aumento de la capacidad: La eliminación de trabajos repetidos permite que un
equipo pueda completar mas trabajo.
» Mejora de estabilidad y calidad: La automatización y estandarización disminuye las
posibilidades de aparición de errores manuales en la entrega de aplicaciones, por el
contrario la automatización mejora la calidad de entrega final.

23. 23
Por otra parte, si bien es cierto que la arquitectura Cliente – Servidor es la que mas usada o
influyente en el mercado, la arquitectura de Cloud ha tenido una buen acogida la cual marca
tendencias gracias a sus ventajas como velocidad en tiempos de respuesta, mejorando
procesos.
Puppet: Podemos concluir que Puppet es una herramienta de gestión de
configuración código abierto, que se encarga de gestionar la configuración de
servidores e implementación de aplicaciones. Servidores con escalabilidad y ayuda
a implementar, escalar verticalmente aplicaciones ya sea en la nube o propias.
Chef: Al igual que la herramienta anterior (Puppet), Chef también es una
herramienta de gestión de configuración de código abierto. Una de las principales
diferencias es que Chef implementa otra versión comercial, por otra parte Chef
utiliza un lenguaje de secuencia de comandos en lenguaje Ruby, denominado
“Recipes”(Recetas).
SaltStack: Esta herramienta de automatización facilita la administración de sistemas
de información integrados por muchos dispositivos.

24. 24
6 Bibliografía
• Blog de Digital Valley. “Instalar SaltStack en Ubuntu”.
<http://www.digitalvalley.com/blog/instalar-salt-stack-en-ubuntu/> [Consultado
en abril de 2016].
• Chef. <https://www.chef.io> [Consultado en marzo de 2016].
• DigitalOcean. “How to create your first salt formula”.
<https://www.digitalocean.com/community/tutorials/how-to-create-your-first-
salt-formula> [Consultado en abril de 2016].
• Notas de ant30. “Puppet, gestión de configuración centralizada”.
<http://www.ant30.es/2011/11/puppet-gestion-de-configuracion-centralizada/>
[Consultado en abril de 2016].
• Puppet Labs. <https://puppetlabs.com> [Consultado en marzo de 2016].
• SaltStack. “Full list of builtin execution modules”.
<https://docs.saltstack.com/en/latest/ref/modules/all/> [Consultado en marzo de
2016].
• SaltStack. < http://www.saltstack.com> [Consultado en marzo de 2016].
• Sysadmin.org.mx. “Administración de múltiples servidores usando Puppet”
<http://www.sysadmin.org.mx/contenidos/administracion-de-multiples-
servidores-usando-puppet.html> [Consultado en marzo de 2016].
• SysTerminal. “Instalación de Chef”.
<http://www.systerminal.com/2014/06/24/instalacion-de-chef-client-debian-y-
ubuntu/> [Consultado en abril de 2016].
• VMware. <https://www.vmware.com> [Consultado en marzo de 2016].