Diario (IV)

Bueno, resulta que el problema parece venir del comando utilizado para ejecutar el script, en vez de
0/30 * * * * /home/pi/ipp.sh
Lo he cambiado a: */30 * * * * . /home/pi/ipp.sh
Ahora todo funciona perfectamente. Si voy a mejorar el script creo que entre las posibilidades podría:

• detectar cuando icanhazip no me devuelve ninguna IP para que no lo interprete como un cambio y no me guarde ese registro, o mejor, espere 1 minuto y lo vuelva a intentar.
• Programar el cron para que por la noche no pregunte que IP tiene.
• Preguntar que IP tengo a mi servidor, en lugar de a icanhazip, así evito intermediarios.

Diario (III)

Para acabar con el script de la anterior entrada, vamos a programar su ejecución en cron. Para hacerlo, primero modificamos los permisos.
chmod u+x ipp.sh
luego ejecutamos el editor de crontab
crontab -e
Dentro del editor programamos la siguiente tarea, para que cada media hora se ejecute cada media hora
0/30 * * * * /home/pi/ipp.sh
Parece que no funciona, más adelante comprobaré a que se puede deber el error.

Diario (II)

Continuamos, al final después de varias pruebas y lecturas (muy útil el siguiente enlace para el tema ssh-keys [en español] [en ingles]). He decidido utilizar ssh sin passphrase y un usuario nuevo que no tenga permisos para ejecutar comandos como root (los famosos sudoers). Este usuario nuevo lo llamare por ejemplo oficina_palma. Vamos al tema. Lo primero será crear el usuario en la Raspberry que me hará de servidor: adduser oficina_palma Introducimos la contraseña que queramos y luego dejamos por defecto todas las opciones que nos van apareciendo. Ahora en la raspberry cliente generamos un par de claves:
ssh-keygen -t rsa -C "Oficina Palma"
Cuando nos pregunte por la passphrase lo dejamos vacío, lo mismo que para el nombre de archivo y ubicación predeterminados. Llegados aquí se han creado los archivos id_rsa e id_rsa.pub. El segundo es la clave publica que copiaré en el servidor. Para hacerlo:
scp ~/.ssh/id_rsa.pub oficina_palma@xxx.xxx.xxx.xxx:
Donde xxx.xxx.xxx.xxx es la dirección ip del servidor. Ojo con los dos puntos finales.
Ahora accedemos al servidor vía ssh con el usuario recién creado:
ssh oficina_palma@xxx.xxx.xxx.xxx
El archivo de claves publicas estará en nuestra home. Lo movemos al directorio oculto .ssh, creamos el archivo authorized_keys al que añadimos las líneas correspondientes a la clave pública. Y luego cambiamos los permisos.
mkdir ~/.ssh
cat ~/id_rsa.pub >> ~/.ssh/authorized_keys
rm ~/id_rsa.pub
chmod 600 ~/.ssh/authorized_keys
chmod go-w ~/.ssh

Para acabar creo un directorio en la carpeta www llamado oficina_palma que es donde subiré todos los archivos que me interesan. Para hacerlo, escribo en el servidor:
sudo mkdir /var/www/oficina_palma
sudo chown -R oficina_palma:oficina_palma /var/www/oficina_palma/
Y listo, ya podemos seguir con nuestro script. Al que solamente añado la ultima linea para hacer una copia en nuestro servidor del texto con la IP, quedaría así:
#!/bin/bash
# Este archivo lo llamamos ipp.sh
actualIP=$(curl -s icanhazip.com)
sleep 30
ultimaLinea=$(tail -n 1 ipp.txt)
ultimaIP=$(expr match "$ultimaLinea" '.*ipp \(.*\)')
if [ "$actualIP" != "$ultimaIP" ];
    then
       echo $(date) "ipp" $a >> ipp.txt
       scp ipp.txt oficina_palma@xxx.xxx.xxx.xxx:/var/www/oficina_palma
fi

Continuamos en otro momento.

Diario (I)

Voy a intentar crear un servidor de paginas web desde la raspberry pi. Tengo una ip estática lo que facilitará bastante el tema. Si consigo que todo vaya ok, luego intentaré hacerlo con ip dinámica. Si no estoy equivocado, ya instalé un servidor apache en la raspberry. Lo compruebo introduciendo la ip local de la misma en el navegador web. Todo ok. De todas formas si lo quisiera instalar de nuevo sólo debo seguir estas instrucciones Compruebo también si tomcat esta instalado. No lo está, de momento no lo necesito. Como hace bastante que no usaba esta raspberry, voy a actualizar el sistema con los clásicos:
sudo apt-get update sudo apt-get upgrade
Mientras la raspberry trabaja, voy mirando documentación de apache. Lo básico que hay que saber es que el directorio por defecto es en /var/www ( en la documentación de raspberry explica que en las nuevas versiones es una diferente, habrá que acordarse de esto en el futuro.
He copiado algunos archivos a un subdirectorio de /var/www lo he llamado web. Voy a 192.168.1.XXX/web. Todo ha funcionado perfectamente.
Llegados a este punto me gustaría que una raspberry que tengo en otro sitio me enviase algunos datos con cierta periodicidad, entre ellos y el más importante la última dirección IP pública ya que es dinámica y no puedo crear un tunel con ella salvo que lo sepa, lo cual me obliga a estar enviando whatsapps cada vez que necesito algo.
Voy a modificar un poco el código que escribí en la entrada Cómo acceder a un Linux desde internet. El código definitivo es:
#!/bin/bash
# Este archivo lo llamamos ipp.sh

# curl es un comando para cargar el código de una páguina web, -s es para el el silent mode (aunque no aprecio diferencia entre una y otra, tal vez debería leer la documentación (otro dia)). La web icanhazip nos devuelve nuestra ip publica. Lo guardo en la variable actualIP.
actualIP=$(curl -s icanhazip.com)

# detengo el script 30 segundos para dar tiempo a que se cargue
sleep 30

# guardo la ultima línea del archivo ipp.txt (si en vez de 1 hubiese puesto 2 hubiese guardado las dos ultimas lineas)
ultimaLinea=$(tail -n 1 ipp.txt)

# entre las comillas simples esta la siguiente expresión regular .*ipp \(.*\) la cual significa . --> cualquier carácter; * --> repetido 0 o más veces; ipp --> literalmente ipp y un espacio; \( --> la barra invertida es para escapar el paréntesis ya que es un carácter reservado de bash, los paréntesis es para capturar ese grupo, es decir que el comando expr devolverá lo que hay entre paréntesis, que es .* --> cualquier caracter aparecido 0 o más veces.
ultimaIP=$(expr match "$ultimaLinea" '.*ipp \(.*\)')

#comparamos las dos variables, si son diferentes actuamos.
if [ "$actualIP" != "$ultimaIP" ];
then
#lo primero es añadir una linea al fichero ipp.txt con la siguiente estructura, la fecha, la cadena ipp y luego la ip.
echo $(date) "ipp" $a >&gt ipp.txt
#lo siguiente es enviar el archivo por scp a la otra direccion ip, la que nos hace de servidor. Otra opcion que se me ocurre es crear un servidor php en la ip estatica y enviarle los datos mediante post.

Hasta aquí por hoy, no puedo dedicarle más tiempo. Continuo otro día, al final del cual dejaré el código pelado para usar.

Chuletas de Bash (II)

Esta es una serie que me sirve de guía para acrodarme de las cuatro cosas básicas de bash. Es caótico y desordenado, pero a mi me va bien. Lo publico por si a alguien le resulta de utilidad.

Si no sigues la serie del principio te recomiendo que lo hagas, es caótica, pero no tanto. A los que seais informáticos puristas tal vez os duela a la vista algo que haga o diga, pero lo que digo siempre, soy industrial... es lo que hay Dicho esto sólo advertir que en este segundo capitulo iré más al grano, si algo no se entiende, ponedlo en comentarios que para eso están y si eso ya hacemos cambios. Bueno al tema.

Vimos como crear variables y expandirlas. Ahora vamos a ver unos cuantos especiales.

$0 nos devuelve el path
$1 nos daria el primer argumento
$2 el segundo, $3 el tercero...
$# nos da el número de argumentos
$@ todos los argumentos


Vamos a hacer un sencillo script, al que llamaremos script02.sh:

#!/bin/bash
echo ""
echo "* Script full command: " $0
echo "* Script first argument: " $1
echo "* Script second argument: " $2
echo "* ..."
echo "* Script number of arguments: " $#
echo "* Script all arguments: " $@
echo ""

Cambiamos los permisos (ver entrada anterior). Y ejecutamos
~$ ./script02.sh escriboCualquierCosa 1237721

Obtenemos:
* Script full command:  ./script02.sh
* Script first argument:  escriboCualquierCosa
* Script second argument:  1237721
* ...
* Script number of arguments:  2
* Script all arguments:  escriboCualquierCosa 1237721

Y esto es todo por hoy.

Chuletas de Bash (I)

Si algo no se entiende ya me preguntáis en los comentarios.

Nota cuando escriba un comando en la terminal lo precederé del prompt siguiente ~$, en MSDOS era el famoso C:\> pero evidentemente el promt no forma parte de la orden, no hay que escribirlo.

Todos los scripts de bash empiezan por:
#!/bin/bash
Esto indica donde debe ir a buscar el script el interprete de comandos.

La primera comando que se debe aprender es echo. echo imprime lo que venga detras por la pantalla. es decir si escribimos en la terminal:
~$ echo "ei, ¿cómo va eso?"
Obtendré:
ei, ¿cómo va eso?

Los comentarios en los scripts se ponen con una almohadilla #. Por ejemplo:
# Esto es un comentario

Las variables son como unos contenedores que guardan "cosas". Para expandir la variable (acceder a su contenido) hay que poner el símbolo $ (que no tiene nada que ver con el prompt, casualidades de la vida). por ejemplo:
a=1 --> guarda el valor 1 en la variable a.
b=2 --> ídem con el valor 2 en la variable b.
echo "La variable a vale:" $a --> nos devuelve La variable a vale: 1
c=$a+$b --> No nos devuelve 3 nos devuelve 1+2. Luego veremos por qué.

Vamos a hacer el primer script. Lo vamos a llamar script01.sh:
#!/bin/bash
a=1
echo "a vale" $a

Guardamos. Si ahora ejecutamos el comando:
~$ ls -l 
veremos algo como:
-rw-r--r-- 1 user01 groupA 1 35 Apr 3 11:57 script01.sh
Vamos a fijarnos en la información por partes -rw-r--r-- ,son 10 caracteres, del primero nos vamos a olvidar de momento. los 3 (rw-)siguientes corresponden al usuario y significa que el usuario que ha creado el archivo (user01, en nuestro caso) tiene ciertos permisos el primero es la r de read (lectura), el segundo es w de write escritura, el tercero es un guión que significa que no tiene permiso para ejecutarlo. Los tres siguientes digitos corresponden al grupo que solo tiene permiso de lectura y los tres últimos son para todo el resto de usuarios.

Como nosotros queremos ejecutar el scrip debemos añadir el permiso de ejecución. Lo haremos mediante el comando chmod (que deberemos ejecutar con permisos de administrador, así que ira precedido por sudo), con el mode u+x esto quiere decir algo como "usuario añadimos ejecucion" :
~$ sudo chmod u+x script01.sh

Si ahora ejecutamos el comando:
~$ ls -l 
veremos algo como:
-rwxr--r-- 1 user01 groupA 1 35 Apr 3 11:57 script01.sh

Ahora ya podemos ejecutar el script:
~$ ./script.sh

Obtendremos:
a vale: 1

Vaya, me ha quedado una entrada algo más larga de lo que quería la próxima será mas condensada.  y presupondrá ciertos conocimientos, si alguien no sabe alguna cosa ya dejará algún comentario.

Chuletas de bash (Introducción)

Siguiendo el nuevo estilo algo caótico de este blog. Me propongo ir haciendo minientradas o no tan mini de apuntes rápidos de bash.

Para quien no lo sepa Bash es un interprete de comandos, http://es.wikipedia.org/wiki/Bash. Y si dicho así puede parecer poca cosa, sin embargo la cantidad de cosas que nos permite hacer (algunas con la ayuda de programas para la terminal), es increíble.

La idea de estas chuletas es para la programación de scripts en bash. Y antes de nada he de decir que no soy informático. Sólo ingeniero industrial, por lo tanto si digo algo que no sea exacto, puro o lo que sea y alguien siente que su calma interior se destruye, que respire profundamente y cambie de blog. Avisados quedáis.