aptsources.sourceslist python module not found

Emplear SaltStack para manejar paquetes y repositorios es algo rápido y que debería ser de las primeras cosas que se implementan. Configurar un repositorio e instalar un paquete es algo así como el "Hola mundo" de la meta-administración. Sin embargo, un posible fallo que acabo de ver en Salt cuando se instala bajo sistemas Debian es que no tiene las dependencias correctamente cumplidas y no permite manejar paquetes, dando el siguiente error.

shell> salt 'salt.domain.com' state.sls salt
salt.domain.com:
----------
      ID: salt
Function: pkgrepo.managed
    Name: deb http://debian.saltstack.com/debian wheezy-saltstack main
  Result: False
 Comment: An exception occurred in this state: Traceback (most recent call last):
     File "/usr/lib/python2.7/dist-packages/salt/state.py", line 1378, in call
       **cdata['kwargs'])
     File "/usr/lib/python2.7/dist-packages/salt/states/pkgrepo.py", line 231, in managed
       sanitizedkwargs = __salt__['pkg.expand_repo_def'](kwargs)
     File "/usr/lib/python2.7/dist-packages/salt/modules/aptpkg.py", line 1361, in expand_repo_def
       'Error: aptsources.sourceslist python module not found'
     CommandExecutionError: Error: aptsources.sourceslist python module not found
 Changes:
...

Como podéis ver, el fallo sale de que desde python, SaltStack está escrito en python, no sabe manejar los repositorios apt y por lo tanto nos soltará el fallo aquí descrito y no establecerá el estado que nos interesa en el sistema, ya que no es capaz. La solución, simplemente instalar el módulo de python para manejar el sistema de paquetería apt. El lógico pensar que no es posible poner de dependencia todos los módulos python que son necesarios, pero éste quizás sí fuese interesante mantenerlo.

shell> apt-get install python-apt

Tras instalar el módulo en el minion, volvemos a lanzar nuevamente el proceso y listo, esta vez ya termina la ejecución correctamente.

shell> salt 'salt.domain.com' state.sls salt
salt.domain.com:
----------
      ID: salt
Function: pkgrepo.managed
    Name: deb http://debian.saltstack.com/debian wheezy-saltstack main
  Result: True
 Comment: Configured package repo 'deb http://debian.saltstack.com/debian wheezy-saltstack main'
 Changes:   
         ----------
         repo:
           deb http://debian.saltstack.com/debian wheezy-saltstack main
----------
...

Leer más

Instalación de salt-minion en Debian Squeeze

Desde la reciente noticia de que Debian squeeze (old-stable) va a ser la primera Debian LTS, cobra más sentido tener presente la instalación de SaltStack bajo este sistema para unirlas al resto de máquinas que ya tenían soporte.

Con antelación, ya expliqué cómo instalar Salt sobre Debian Wheezy, sin embargo, este tipo de instalación no sirve para la antigua versión estable de Debian. Si sigues la chuleta descrita, tras crear el fichero /etc/apt/sources.list.d/salt.list con el contenido de squeeze correspondiente, quedando tal que así,

deb http://debian.saltstack.com/debian squeeze-saltstack main

Al intentar instalar el paquete salt-minion, el resultado no es precisamente el deseado.

shell> apt-get install salt-minion
Leyendo lista de paquetes... Hecho
Creando árbol de dependencias       
Leyendo la información de estado... Hecho
No se pudieron instalar algunos paquetes. Esto puede significar que
usted pidió una situación imposible o, si está usando la distribución
inestable, que algunos paquetes necesarios no han sido creados o han
sido movidos fuera de Incoming.
La siguiente información puede ayudar a resolver la situación:

Los siguientes paquetes tienen dependencias incumplidas:
 salt-minion : Depende: msgpack-python pero no es instalable
               Depende: python-zmq (>= 13.1.0) pero no va a instalarse
E: Paquetes rotos

Por lo tanto, para poder instalar salt bajo Debian squeeze, debemos de añadir la siguiente línea al fichero salt.list.

deb http://backports.debian.org/debian-backports squeeze-backports main contrib

Sí, efectivamente, acabamos de añadir soporte, si es que no lo teníamos ya, a los repositorios backports de Debian. Ahora ya podemos instalar sin problema alguno salt-minion en Debian squeeze.

shell> wget -q -O- "http://debian.saltstack.com/debian-salt-team-joehealy.gpg.key" | apt-key add -
shell> apt-get update
shell> apt-get install salt-minion

Más información:

• docs.saltstack.com

Leer más

Manejar extensiones Libre Office desde terminal

Siempre que trabajamos con sistemas de administración centralizada como Puppet o SaltStack, tenemos que tener presente que todos los procesos que ejecutemos deben ser desde consola, que el concepto "interfaz gráfico" ya no está disponible. Esto en Linux no suele ser un problema, pero hay ciertas acciones que sí que pueden hacer que tengamos que replantearnos cómo hacerlas.

Este es el caso de las extensiones de OpenOffice/LibreOffice. La instalación de la suite ofimática en el sistema es sencilla, puesto que está en los repositorios, únicamente hay que hacer que esté presente en los sistemas. El problema está en las extensiones, que son pequeños ficheros que nos descargamos de la web y que tenemos que instalar en cada una de las máquinas. La forma de hacerlo es desde el propio interfaz, pero claro, si pensamos en hacerlo en 50 equipos, por ejemplo, la cosa ya cambia.

Por suerte, para simplificar este proceso, existe el comando unopkg, que sirve para instalar o desinstalar extensiones en el sistema, pero desde línea de comandos. Así que, tras descargar la extensión que nos haga falta desde la web oficial, es.libreoffice.org/extensiones, únicamente tendremos que ejecutar lo siguiente,

shell> unopkg add --shared pager.oxt

En caso de que la extensión a instalar ofrezca un menú con licencia para aceptar, lo más sencillo es aceptar la licencia de base y que no se muestre, sino no se podrá instalar. Para ello, habrá que hacer lo mismo, pero con la opción -s, tal que así,

shell> unopkg add -s --shared pager.oxt

Espero que os sea útil si tenéis que mantener un cierto número de suites ofimáticas, en las que a mayores del paquete Office hay que manejar extensiones.

Leer más

Facter: Ampliando sus posibilidades

Para aquellos que no lo sepan, Facter es una pequeña librería en la que se apoya Puppet, multiplataforma, y que sirve para obtener información de los sistemas. Su integración con Puppet es máxima y es gracias a ella que facilita la toma de decisiones según los equipos.

Desde la versión 1.7 de Facter, se han incluido una gran cantidad nueva de facts, lo que permite ya de base poder obtener mucha más información de los equipos. A mayores de este duro trabajo, también han creado una forma muy lógica y siguiendo el uso en Linux, de extender su funcionalidad. Desde esta nueva versión, es posible crear nuevas variables, escritas en texto, json o yaml. Según el tipo de fichero que creemos, debemos de emplear su sintaxis correcta.

Tras actualizar la versión de facter empleada, para comenzar a crear nuestras propias variables, únicamente debemos de crear la carpeta que las va a contener,

shell> mkdir /etc/facter/facts.d

Y a continuación, meter ahí todos los ficheros que deseemos para extender las funcionalidades que deseemos. Por ejemplo, según el formato,

• .yaml

  key1: val1
  key2: val2
  key3: val3
  

• .json

  {
     "key1": "val1",
     "key2": "val2",
     "key3": "val3"
  }
  

• .txt

  key1=value1
  key2=value2
  key3=value3
  

Tras ello, simplemente con ejecutar facter podremos ver las nuevas variables que hemos creado.

shell> facter | grep key

Si empleáis Puppet, creo que esta nueva opción os resultará, sin duda, de bastante utilidad.

Más información:

• docs.puppetlabs.com/custom_facts

Leer más

SaltStack: Uso de grains

¿Os leísteis ya la entrada sobre SaltStack de primeros pasos con Salt? Si no lo habéis hecho, antes de seguir, este es un buen momento para hacerlo aquí.

En esa primera entrada explicábamos como dar de alta un nuevo equipo en el servidor, aceptar su clave y hacer una primera prueba de concepto. Hoy vamos a ver un nuevo punto en la arquitectura de SaltStack: los grains.

Los grains son los datos del sistema del cliente SaltStack. Estos datos son los que nos indican el tipo de sistema operativo, el dominio al que pertenece, la IP, RAM, versión y un largo etc.

Para obtener la salida de grains, podemos hacerlo tal que así,

shell> salt '*' grains.items
  biosreleasedate: 01/01/2006
  biosversion: Bochs
  cpu_flags: fpu de pse tsc msr pae mce cx8 apic sep mtrr...
  cpu_model: QEMU Virtual CPU version 1.1.2
  cpuarch: x86_64
  defaultencoding: UTF-8
  defaultlanguage: en_GB
  domain: mydomain.local
  fqdn: test.server.local
  gpus:
      {'model': 'GD 5446', 'vendor': 'unknown'}
  host: sei
  id: sei.mydomain.local
  ip_interfaces: {'lo': ['127.0.0.1'], 'eth0': ['10.1.100.15']}
  ipv4:
      127.0.0.1
      10.1.100.15
  kernel: Linux
  kernelrelease: 3.9-1-amd64
  localhost: sei
  lsb_distrib_codename: jessie
  lsb_distrib_description: Debian GNU/Linux testing (jessie)
  lsb_distrib_id: Debian
  lsb_distrib_os: GNU/Linux
  lsb_distrib_release: testing
  manufacturer: Bochs
  master: salt
  mem_total: 2012
  nodename: sei
  num_cpus: 1
  num_gpus: 1
  os: Debian
  os_family: Debian
  oscodename: jessie
  osfullname: Debian
  osrelease: testing
  path: /sbin:/usr/sbin:/bin:/usr/bin
  productname: Bochs
  ps: ps -efH
  pythonpath:
      /usr/bin
      /usr/lib/python2.7
      /usr/lib/python2.7/plat-x86_64-linux-gnu
      /usr/lib/python2.7/lib-tk
      /usr/lib/python2.7/lib-old
      /usr/lib/python2.7/lib-dynload
      /usr/local/lib/python2.7/dist-packages
      /usr/lib/python2.7/dist-packages
      /usr/lib/pymodules/python2.7
  pythonversion: 2.7.5.final.0
  saltpath: /usr/lib/python2.7/dist-packages/salt
  saltversion: 0.16.2
  serialnumber: Not Specified
  bash: /bin/bash

Estos datos los podemos emplear dentro de la lógica de Salt, como veremos un poco más adelante y también para diferenciar los equipos en los que queramos ejecutar algo.

Si os acordais, para lanzar una prueba, hacíamos los siguiente

shell> salt '*' test.ping

Con ello, ejecutábamos la función test.ping en todos los equipos que estuviesen aceptados en el servidor. Usando grains, podemos hacer una selección de los mismos sobre la que ejecutar los comandos. Para ello tenemos la opción -G, que la seguimos de la opción por lo que deseamos diferenciar.

shell> salt -G 'os:Debian' test.ping
shell> salt -G 'cpuarch:x86_64' test.ping

Como podéis observar, en la primera se ejecuta el comando sobre todos aquellos equipos con sistema operativo Debian, mientras que en el segundo ejemplo, sobre todos aquellos equipos de arquitectura x86_64.

La entrada SaltStack: Uso de grains la puedes leer en Puppet Linux.

Leer más

Instalar SaltStack Ubuntu

Hace un tiempo explicamos en este blog cómo instalar un cliente SaltStack sobre un equipo corriendo Debian. Hoy vamos a ver cómo instalar SaltStack en Ubuntu, ya que hay mucha gente que me preguntó cómo hacerlo bajo algo que no sea Debian, especialmente por el tirón que están teniendo las versiones LTS de este sistema operativo.

En realidad es prácticamente igual, pues ambos son de la misma familia. La única salvedad es la forma en la que agregar el repositorio de datos, que en sistemas Ubuntu podemos emplear los repositorios ppa de forma más sencilla. Por lo tanto para instalar SaltStack,

shell> add-apt-repository -y ppa:saltstack/salt

Una vez que tenemos ya es repositorio, únicamente

shell> apt-get update
shell> apt-get install {salt-minion | salt-master | salt-syndic}

Espero que os sea de ayuda.

La entrada Instalar SaltStack minion (Ubuntu) la puedes leer en Puppet Linux.

Leer más

SaltStack: Primeros pasos

Una vez tenemos ya finalizada la instalación de un servidor SaltStack y un cliente o minion, es hora de comenzar a trabajar y ver de qué es capaz.

Lo primero de todo, debemos de tener claro que la comunicación entre cliente y servidor siempre viaja cifrada. El sistema usado es de clave pública--privada, muy similar a SSH, así que el cliente va a generar una clave y tendrá que compartirla con el servidor. Éste luego deberá aceptarla (o no) antes de comenzar a intercambiar datos.

Siempre desde la shell del servidor de Salt, podemos ejecutar,

shell> salt-key -L
Accepted Keys:
Unaccepted Keys:
  salt-client-1.local.net
Rejected Keys:

Para ver un listado de los servidores que ya tenemos aceptados dentro del master y también los que están rechazados. Como veis el nombre del equipo es siempre el que se configura en el minion, y excepto que lo cambiemos manualmente, por defecto cogerá el nombre del equipo, con dominio.

Si tenemos algún equipo pendiente de aceptar, lo que tendremos que ejecutar es,

shell> salt-key -A
The following keys are going to be accepted:
Unaccepted Keys:
  salt-client-2.local.net
Proceed? [n/Y] Y
  Key for minion salt-client-2.local.net accepted.

shell> salt-key -L
Accepted Keys:
  salt-client-1.local.net
  salt-client-2.local.net
Unaccepted Keys:
Rejected Keys:

Ahora que ya los tenemos aceptados, ya podemos comenzar a trabajar con los clientes de forma sencilla. Lo más básico, ver que un equipo responde a ping,

shell> salt 'salt-client-1.local.net' test.ping
salt-client-1.local.net:
    True

O que todos responden a ping,

shell> salt '*' test.ping
salt-client-1.local.net:
    True
salt-client-2.local.net:
    True

Aunque también se pueden hacer cosas más concretas e interesantes como,

shell> salt '*' cmd.run 'cat /etc/debian_version'
salt-client-2.local.net:
    7.1
salt-client-1.local.net:
    7.0

U ordenarle que hagan un ping a Google y que nos devuelva el resultado,

shell> salt -L 'salt-client-*' network.ping '8.8.8.8'
salt-client-1.local.net:
    PING 8.8.8.8 (8.8.8.8) 56(84) bytes of data.
    64 bytes from 8.8.8.8: icmp_req=1 ttl=45 time=53.1 ms
    64 bytes from 8.8.8.8: icmp_req=2 ttl=45 time=48.4 ms
    64 bytes from 8.8.8.8: icmp_req=3 ttl=45 time=50.4 ms
    64 bytes from 8.8.8.8: icmp_req=4 ttl=45 time=48.2 ms

    --- 8.8.8.8 ping statistics ---
    4 packets transmitted, 4 received, 0% packet loss, time 3004ms
    rtt min/avg/max/mdev = 48.211/50.052/53.184/2.019 ms

salt-client-2.local.net:
    PING 8.8.8.8 (8.8.8.8) 56(84) bytes of data.
    64 bytes from 8.8.8.8: icmp_req=1 ttl=45 time=51.1 ms
    64 bytes from 8.8.8.8: icmp_req=2 ttl=45 time=48.3 ms
    64 bytes from 8.8.8.8: icmp_req=3 ttl=45 time=48.3 ms
    64 bytes from 8.8.8.8: icmp_req=4 ttl=45 time=48.1 ms

    --- 8.8.8.8 ping statistics ---
    4 packets transmitted, 4 received, 0% packet loss, time 3004ms
    rtt min/avg/max/mdev = 48.162/48.991/51.149/1.257 ms

Como creo que vais observando desde la shell del servidor de SaltStack siempre se ejecuta el comando salt, seguido de

• '*', 'salt-client-1'
  
  Es el nombre del cliente al que queremos conectar.
  Puede usar comodines o expresiones regulares si nos interesa conectar a uno o más de uno. También se permite conecta a uno o varios equipos según arquitectura, sistema operativo, etc.
• cmd.run, test.ping
  
  Es el comando que vamos a ejecutar. Por defecto SaltStack tiene muchos ya definidos, los cuales podemos y debemos usar.
• '8.8.8.8'
  
  Son los parámetros opcionales que se le pueden pasar a un comando.

Como primera aproximación no está mal. En próximas entradas iremos viendo cómo hacer más cosillas con SaltStack, cosas que realmente ya será de interés y aportarán algo a la administración de sistemas.

La entrada SaltStack: Primeros pasos, la puedes leer en Puppet Linux.

Leer más

Instalar SaltStack minion

El otro día comenzamos con al instalación del servidor de SaltStack y hoy vamos a ver cómo realizar la instalación de un cliente SaltStack. La instalación del cliente será sobre un sistema Debian, pero es el mismo procedimiento cualquier sistemas de la familia Unix.

Al igual que hicimos para la instalación del servidor, vamos a crear el cliente el siguiente fichero, /etc/apt/sources.list.d/salt.list con,

deb http://debian.saltstack.com/debian wheezy-saltstack main

Tras ello y siguiendo los mismos pasos que para el servidor, importamos la clave GPG y actualizamos el listado de paquetes disponibles.

shell> wget -q -O- "http://debian.saltstack.com/debian-salt-team-joehealy.gpg.key" | apt-key add -
shell> apt-get update

Ahora, antes de instalar el cliente, vamos a hacer un pequeño truco que nos simplificará la vida a la hora de comenzar a trabajar. Por defecto el nuevo minion al arrancar se conecta a un servidor llamado salt. Si tenemos un DNS en nuestra red, es hora de crear esta entrada en él y que apunte a la IP del servidor. En caso contrario, podemos hacer el truco de crear una entrada en el fichero /etc/hosts apuntando a dicha IP.

192.168.1.50   salt   salt.domain.com

Ahora ya estamos en condiciones de instalar el software que necesitamos. Para ello,

shell> apt-get install salt-minion

Puesto que en nomenclatura SaltStack un cliente es un minion el paquete adoptó dicho nombre. Durante la instalación resolverá las dependencias necesarias, entre ellas todos los temas de Python que necesitemos.

Al finalizar la instalación el software quedará ejecutándose y habrá realizar ya la primera conexión al servidor (si hemos creado la entrada apuntando al nombre salt) y ya estamos listos para comenzar a trabajar. En la próxima entrada, veremos cómo dar los primeros pasos con Salt.

Más información en la documentación oficial de SaltStack.

La entrada Instalar SaltStack minion la puedes leer en Puppet Linux.

Leer más

Instalar SaltStack server

Hace unos 15 días comencé a mirar cosas nuevas acerca de orquestación y aprovisionamiento de equipos. Ya es conocido Puppet, del que tengo hablado más de una vez en este blog. Sin embargo, a Puppet le falta alguna solución para la ejecución de comandos remotos. Si bien es cierto que gracias a MCollective esos problemas se pueden solucionar, hay que añadir algo que en su origen no era nativo y que por defecto suele ser bastante complejo.

Para solucionar este problema, y también cambiando un poco la forma de trabajar, vamos a comenzar por dar unas nociones básicas de SaltStack. Próximamente dedicaremos un post más extenso y teórico acerca de las bondades y diferencias entre SaltStack vs. Puppet, pero primero vamos a ejercer de técnicos y realizar una instalación y configuración se un servicio basado en Salt. Hoy será de la parte del servidor.

Si tenemos un equipo con Ubuntu, Salt está disponible en los repositorios oficiales (paquete salt-master), sino podemos emplear los paquetes que nos ofrece el desarrollador, contando así con la última versión disponible. Para ello, en sistemas Debian, creamos el fichero /etc/apt/sources.list.d/salt.list con el siguiente contenido (actual versión estable).

deb http://debian.saltstack.com/debian wheezy-saltstack main

A continuación procedemos a instalar el servidor. Para ello,

shell> wget -q -O- "http://debian.saltstack.com/debian-salt-team-joehealy.gpg.key" | apt-key add -
shell> apt-get update
shell> apt-get install salt-master

Ya tenemos el servidor instalado. La clave GPG que importamos es la del repositorio de saltstack.com. Si no lo hacemos, simplemente nos dará un error de confianza de clave.

Salt está escrito en Python, por lo que necesitará instalar varias dependencias de éste para funcionar, tanto en la parte del cliente como lógicamente en la del servidor.

Si te parece interesante la instalación del servidor SaltStack, mira cómo instalar un cliente (o minion) en GNU/Linux.

Más información en la documentación oficial de SaltStack.

La entrada Instalar SaltStack server está disponible en Puppet Linux.

Leer más