SaltStack es un software de código abierto basado en Python que sirve para automatizar la ejecución remota de tareas y configuraciones.
Es de la familia de Chef, Puppet y Ansible, sobre este ultimo hablamos en el blog.
A través de la "Infraestructura como código", SaltStack nos permite realizar la implementación y administración de sistemas, automatización de la configuración, orquestación, corrección de vulnerabilidades, etc.
La arquitectura de SaltStack:
Utiliza una arquitectura maestro-esclavo y sus componentes mas importantes son:
Master: Servidor que se comunica con los agentes instalados en los dispositivos finales llamados Minions.
Minions : Son los nodos en los cuales se instala un agente que le permite al Master administrarlos y ejecutar comandos de forma remota.
Grains: Es una interfaz que proporciona información del sistema, como el sistema operativo, la memoria, el nombre de dominio, el núcleo, la dirección IP, etc.
States: Los estados son archivos YAML (.SLS) para almacenar la configuración de los Minions.
El Master y los Minions se comunican a través de Keys. Una vez que se forma una red segura entre ellos, el cliente puede comunicarse sin problemas con el Master para recibir instrucciones.
Instalar SaltStack:
Agregamos la llave del repo:
wget -O - https://repo.saltstack.com/py3/ubuntu/20.04/amd64/latest/SALTSTACK-GPG-KEY.pub | sudo apt-key add -
Agregamos el repo en /etc/apt/sources.list.d/saltstack.list:
deb http://repo.saltstack.com/py3/ubuntu/20.04/amd64/latest focal main
Actualizamos el sistema:
sudo apt-get update
Instalación del Master:
sudo apt-get install salt-master
Verificamos la versión:
salt --versions-report
Ahora editamos el archivo del Master:
sudo nano /etc/salt/master
Y cambiamos las siguientes lineas:
interface: 192.168.2.116
gather_job_timeout: 120
timeout: 120
Verificamos el estado del Master:
systemctl status salt-master
Verificamos las llaves:
sudo salt-key -L
Vemos que no hay ninguna Aceptada, ni Denegada ni Rechazada.
Instalación del Minion:
Agregamos la llave del repo:
wget -O - https://repo.saltstack.com/py3/ubuntu/20.04/amd64/latest/SALTSTACK-GPG-KEY.pub | sudo apt-key add -
Agregamos el repo en /etc/apt/sources.list.d/saltstack.list:
deb http://repo.saltstack.com/py3/ubuntu/20.04/amd64/latest focal main
Actualizamos el sistema:
sudo apt-get update
Ahora instalamos el Minion:
sudo apt-get install salt-minion
Editamos el archivo del Minion:
sudo nano /etc/salt/minion
Y agregamos las siguientes lineas:
master: 192.168.2.116
id: primer-minion
Verificamos el estado del Minion:
systemctl status salt-minion
En la parte del archivo minion donde decía master podríamos haber dejado la palabra salt y editar el archivo /etc/hosts asignándole a salt la IP del servidor, pero para los fines de este ejemplo directamente usamos la IP y no el nombre DNS.
Reiniciamos el servicio para que el Minion intente conectarse al Master:
systemctl restart salt-minion
Chequeamos las llaves en el Master:
sudo salt-key -L
Y vemos que ya nos aparece el primer-minion (que es el ID con el que definimos nuestro Minion) pero en las keys no aceptadas:
Aceptamos la key:
sudo salt-key -a primer-minion
Podríamos aceptar las llaves de todos los Minions de una, en caso de que hubiera varios, usando la opción -A:
sudo salt-key -A
Chequeamos de nuevo y vemos que la acepto:
sudo salt-key -L
 |
| Vemos que en Accepted ya aparece primer-minion |
sudo salt 'primer-minion' test.ping
Probamos verificar la IP del Minion:
sudo salt 'primer-minion' grains.item ipv4
En mi caso la IP del Minion es 192.168.2.120 (la 127 es la loopback y la otra de Docker).
Podemos ver el espacio en disco del Minion:
sudo salt 'primer-minion' disk.usage
Ahora hacemos un ls en /home/ardillasenlared del Minion:
sudo salt '*' cmd.run 'ls -l /home/ardillasenlared'
Por ultimo probamos crear un archivo en el Minion:
Nos fijamos que archivos tenemos en la home del Minion:
Ahora vamos al Master y creamos un archivo en la home del Minion ejecutando:
salt 'primer-minion' file.touch /home/ardillasenlared/CreadoDesdeMaster.txt
Vemos que aparentemente lo creó. Ahora chequeamos el Minion, y vemos que efectivamente esta creado:
 |
| Antes y Después |
Vemos que actualmente el Minion no lo tiene instalado:
Instalamos Apache desde el Master:
sudo salt 'primer-minion' pkg.install apache2
Verificamos el Minion otra vez:
Ahora vamos a probar instalar un programa a través de un archivo SLS.
“SLS” se refiere a SaLt State, y representan el estado en que se desea que esté el sistema.
Estos archivos se escriben, al igual que Ansible, en formato YAML.
Los estados se almacenan en archivos de texto en el Master y se transfieren a los Minions a través del servidor de archivos del Master.
Primero en /etc/salt/master editamos lo siguiente:
En la sesión "State System settings" descomentamos:
state_top: top.sls
Y en "File Server settings":
file_roots:
base:
- /srv/salt
La configuración del sistema se realiza en /srv/salt/top.sls, y luego se aplica ejecutando la función state.apply para que el Master de Salt ordene a sus Minions que actualicen sus instrucciones y ejecuten los comandos asociados.
Creamos el archivo top.sls:
sudo touch /srv/salt/top.sls
Cuando el archivo está vacío, o si no se encuentra ninguna configuración para nuestro Minion, se informa un error:
sudo salt 'primer-minion' state.apply
El archivo top está separado en entornos. El entorno por defecto es base, que es el que vamos a usar nosotros. Bajo el entorno base se define una colección de Minions (en nuestro caso uno solo, aunque podriamos definir '*' para que sean todos).
Una vez creado top.sls le agregamos las siguiente lineas:
base:
'primer-minion':
- apacheinstall
Vamos a crear un sls para instalar Apache en el Minion con el nombre que pusimos ahí (apacheinstall), pero primero chequeamos que el Minion no lo tenga instalado:
Creamos en /srv/salt/ (en el mismo directorio que tenemos top.sls) el archivo apacheinstall.sls:
sudo nano apacheinstall.sls
Y pegamos este código:
apache2:
pkg.installed:
- name: apache2
service.running:
- enable: True
- reload: True
La primera linea (apache2:) es un identificador arbitrario, en este caso nos dice el nombre del paquete que se va a instalar.
En la segunda linea tenemos la declaración de estado (pkg), que nos dice cual de los estados de Salt vamos a utilizar, y la función del modulo a utilizar (installed).
Luego verifica que el servicio con nombre apache2 este corriendo (y sino lo habilita) y hace un reload de la configuración en caso que este activo.
Guardamos y ejecutamos de nuevo el state.apply:
sudo salt 'primer-minion' state.apply
Y vemos que lo instalo:
Ahora verificamos el Minion:
Si quisieramos removerlo podríamos crear un apacheremove.sls con este código:
apache2:
pkg.removed:
- name: apache2
Luego modificamos el top.sls y cambiamos apacheinstall por apacheremove. Por último ejecutamos nuevamente el state.apply:
sudo salt 'primer-minion' state.apply
Verificamos en el Minion que el servicio ya no esté activo:
Y listo, ya lo instalamos, lo configuramos y aprendimos nuestros primeros comandos.
Espero que les haya servido.
Saludos!
No hay comentarios:
Publicar un comentario