hits counter
Este sitio web utiliza cookies para obtener estadísticas de navegación. Si sigue adelante, consideraremos que acepta su uso. Acepto | Más información

Utilidades:



Varias terminales en una sola pantalla

Cuando trabajamos en la terminal, con la línea de comandos, es muy útil tener la posibilidad de usar varias terminales al mismo tiempo. Esto podemos hacerlo de varias formas: por ejemplo, abriendo varias sesiones de SSH. Pero hay una forma mejor y más práctica: instalar la utilidad tmux, que es lo que se denomina un multiplexor de terminales. Con ella podemos dividir la pantalla de nuestra terminal en varias terminales más pequeñas, crear nuevas pantallas (o ventanas) que contengan, a su vez, varias terminales y saltar de una a otra con una simple combinación de teclas.

Así pues, vamos a instalar esta utilidad:

sudo apt install tmux

Una vez terminada la instalación, ya tenemos tmux listo para usar. Lo lanzamos:

tmux

y lo usamos empleando la combinación de teclas Ctrl+b seguida de otra tecla. He aquí las más comunes:

Ctrl+b %  ->  divide en horizontal 
Ctrl+b "  ->  divide en vertical  
Ctrl+b o  ->  cambia de una a otra  
Ctrl+b flechas  ->  cambia a la terminal donde apunte la flecha  
Ctrl+b x  ->  cierra una terminal [abajo, izquierda, aparece (y/n)]
Ctrl+b c  ->  crea una nueva ventana
Ctrl+b p  ->  vuelve a la ventana anterior
Ctrl+b n  ->  pasa a la ventana siguiente
Ctrl+b &  ->  cierra ventana actual [abajo, izquierda, aparece (y/n)]

Este es el resultado de dividir una pantalla en cuatro terminales:




Poner el disco duro en suspensión

Si conectamos un disco duro externo a la Raspberry, tal y como explicamos más arriba, a no ser que la caja posea un mecanismo para poner el HD en estado de suspensión pasado un cierto tiempo, lo normal es que el disco permanezca continuamente en movimiento, incluso cuando no se está haciendo uso de él, lo que supone un gasto de energía innecesario. Para evitar esto, podemos instalar una utilidad que se encargue de llevar a cabo este proceso.


hdparm

Este servicio es el más fácil de instalar y usar, pero tiene el inconveniente de que no todos los discos duros funcionan con él, especialmente los que se conectan por USB, como es el caso de la Raspberry, ya que esta placa carece de puerto SATA. Lo mejor es probar y ver si funciona con nuestro HD. De no ser así, entonces usaremos hd-idle, cuya instalación se explica más adelante.

Lo instalaremos de la forma habitual:

sudo apt install hdparm

hdparm posee una larga lista de parámetros que se pueden utilizar. Podemos verlos todos aquí. Según se observa, el parámetro -S es el que establece el tiempo de espera antes de poner la unidad en suspensión (standby o spindown). Al usarlo, a continuación debemos añadir un valor numérico que determinará cuál será el tiempo de espera (durante el que no hay actividad del disco) antes de ponerlo en suspensión para ahorrar energía. Seguido de este número vendrá el nombre de la unidad de disco a la que queremos que se aplique (que podemos averiguar previamente con el comando sudo fdisk -l). Por ejemplo:

sudo hdparm -S 60 /dev/sda

La codificación del valor de tiempo de espera es bastante peculiar. El valor 0 significa que el tiempo de espera está deshabilitado y, por consiguiente, el dispositivo no entrará automáticamente en standby. Los valores del 1 al 240 especifican múltiplos de 5 segundos, produciendo tiempos de espera de entre 5 segundos y 20 minutos. Los valores del 241 al 251 indican unidades con intervalos de 30 minutos, cuyos tiempos de espera van desde los 30 minutos a las 5,5 horas. El resto de valores son especiales. Todos ellos podemos verlos en este listado.

Para no tener que escribir el comando anterior cada vez que arranquemos nuestra Raspberry, lo mejor es ponerlo en el fichero de configuración de hdparm para que quede establecido de forma permanente. Así que editamos dicho fichero:

sudo nano /etc/hdparm.conf

y, al final del mismo, escribimos lo siguiente:

/dev/sda {
    spindown_time = 120
}

Como vemos, la sintaxis es diferente a cuando lo usamos directamente desde la línea de comandos. Aquí no se usa el parámetro -S, sino spindown_time, que en este ejemplo le hemos asignado un valor de 120, lo que equivale a 10 minutos de espera (120x5=600 segundos, que son 10 minutos).

Haciendo lo anterior, el spindown debería iniciarse correctamente transcurrido el tiempo indicado. Sin embargo, en algunos discos es necesario, además, activar (descomentándola) esta opción:

apm = 255

Por último, reiniciaremos el sistema para que se active el servicio y comprobar que funciona correctamente:

sudo reboot

Otros parámetros de hdparm

Con el parámetro -C podemos comprobar el estado de la unidad:

sudo hdparm -C /dev/sda

Obtendremos estas respuestas según esté el disco activo o en suspensión:

drive state is: active/idle
drive state is: standby

Para forzar el estado de suspensión, usaremos -y:

sudo hdparm -y /dev/sda

Lo que nos devolverá esta respuesta:

issuing standby command

Una lista completa de todos los parámetros puede obtenerse con

sudo hdparm -h

NOTA: Puede que estos parámetros (o alguno de ellos) no funcionen bien en determinados modelos de discos y obtengamos el mensaje drive state is: unknown junto a algún otro mensaje de error (por ejemplo, SG_IO: bad/missing sense data), pero esto no significa forzosamente que el servicio no esté realizando de forma correcta su función, que es la de poner el disco en suspensión una vez transcurrido el tiempo estipulado.


hd-idle

Si la aplicación anterior no funcionara, entonces la desinstalamos (sudo apt purge hdparm) y probamos con hd-idle, que suele ser más adecuada para los discos USB. El proceso lo haremos en varios pasos, instalando primero algunas herramientas que son necesarias:

sudo apt install build-essential fakeroot debhelper -y

Después descargamos la última versión de hd-idle (que podemos conocer en este enlace):

wget http://sourceforge.net/projects/hd-idle/files/hd-idle-1.05.tgz

Y por último descomprimimos el fichero e instalamos el paquete:

tar -xvf hd-idle-1.05.tgz && cd hd-idle
dpkg-buildpackage -rfakeroot
sudo dpkg -i ../hd-idle_*.deb

Ya podemos poner en suspensión el disco duro con el comando que mostramos a continuación, al final del cual se indica el nombre de nuestra unidad de disco (lo que es posible averiguar previamente escribiendo sudo fdisk -l):

sudo hd-idle -t sda

Para no tener que escribir el comando anterior cada vez que arranquemos la Raspberry, lo mejor es ponerlo en el fichero de configuración de hd-idle para que quede establecido de forma permanente. Así que editamos dicho fichero:

sudo nano /etc/default/hd-idle

y modificamos las líneas que se muestran a continuación, indicando en la segunda el tiempo que ha de transcurrir (en segundos) hasta que el HD entre en standby:

START_HD_IDLE=true
. . . . . .
. . . . . .
HD_IDLE_OPTS="-i 300 -l /var/log/hd-idle.log"

Si tuviéramos conectados varios discos, habría que modificar la segunda línea de manera que indique al principio el tiempo por defecto y luego el de cada unidad:

HD_IDLE_OPTS="-i 300 -a sda -i 600 -a sdb -i 1200"

Ya podemos reiniciar el servicio:

sudo service hd-idle restart

o bien el sistema para comprobar que funciona correctamente tras el reinicio:

sudo reboot



Certificado SSL de Let's Encrypt

Puesto que cada vez es más necesario dotar de un acceso seguro a cualquier sitio web, vamos a convertir nuestro servidor Apache o Nginx en un servidor web seguro que use el protocolo HTTPS. Para ello necesitaremos añadir un certificado SSL de una Autoridad de Certificación. Normalmente este certificado se incluye en la compra del dominio. Pero si vamos a usar un DNS dinámico (DDNS), como No-ip, por ejemplo, no dispondremos de él. Afortunadamente, Let's Encrypt nos proporciona de forma gratuita dicho certificado.

Antes de nada, lo primero que haremos será abrir los puertos 80 y 443 TCP en el router y redirigirlos a la IP local de la Raspberry. Si usamos un cortafuegos, también tendremos que abrirlos en él.


Obtención del certificado

Este proceso lo vamos a realizar en tres pasos:

1.) Instalamos Cerbot, el cliente de Let's Encrypt que nos permitirá automatizar la emisión e instalación de certificados, además del paquete que se encarga de automatizar esta tarea en el servidor web.

  1. Si usamos Apache:
    sudo apt install certbot python3-certbot-apache
  2. En el caso de Nginx:
    sudo apt install certbot python3-certbot-nginx

2.) Y ahora es cuando vamos a obtener el certificado.

  1. Para Apache usaremos este comando (sustituyendo midominio.com por el nuestro):
    sudo certbot --apache -d midominio.com
  2. Para Nginx el comando es similar:
    sudo certbot --nginx -d midominio.com

Durante el proceso de instalación del certificado se nos pedirá un email. Este correo electrónico es para la recuperación de claves y recibir notificaciones cuando esté próximo a caducar, por lo que es importante que sea un email válido. Se utilizará además para avisarnos en el caso de que se produzca un error durante el proceso de renovación automática del certificado. Luego tenderemos que aceptar los Términos del Servicio y se nos preguntará si queremos compartir nuestro email con la Electronic Frontier Foundation a fin de recibir noticias e información sobre campañas de apoyo a la libertad digital de la EFF.

3.) Ya sólo falta reiniciar el servidor.

  1. Si es Apache:
    sudo service apache2 restart
  2. En el caso de Nginx:
    sudo service nginx restart

Podemos verificar el estado de nuestro certificado SSL y su fecha de caducidad en esta página:

https://www.ssllabs.com/ssltest/analyze.html

Renovar el certificado

El certificado proporcionado por Let's Encrypt sólo es válido durante 90 días, por lo que es necesaria su renovación periódica. Podemos simular la renovación y comprobar que funciona correctamente mediante este comando:

sudo certbot renew --dry-run

Aunque la auténtica renovación se hace con

sudo certbot renew

Es posible automatizar la tarea de renovar el certificado recurriendo a cron. Para ello editamos su fichero de configuración:

crontab -e

y al final del mismo añadimos una línea para que se ejecute la autorenovación, por ejemplo, todos los viernes a las 3 de la madrugada:

0 3 * * 5 sudo /usr/bin/certbot renew --quiet

Guardamos los cambios y reiniciamos cron:

sudo service cron restart

Recordemos que se puede verificar el estado de nuestro certificado SSL y su fecha de caducidad en esta página:

https://www.ssllabs.com/ssltest/analyze.html

Copia de seguridad del certificado

En caso de que en un futuro se dañe el directorio /etc/letsencrypt, que es donde se encuentra el certificado, podemos hacer copia de seguridad del mismo y restaurarlo después. En primer lugar hacemos la copia:

sudo tar zcvf letsencrypt_backup_$(date +'%Y-%m-%d_%H%M').tar.gz /etc/letsencrypt

Posteriormente, en el momento en que lo necesitemos, procederemos a su restauración. La haremos en dos pasos.

1.) Primero ejecutamos este comando para restaurar los archivos:

sudo tar zxvf letsencrypt_backup_XXXX-XX-XX_XXXX.tar.gz -C /

Sustituiremos, naturalmente, las XXXX-XX-XX_XXXX por los números correspondientes del fichero que contiene la copia de seguridad.

2.) En segundo lugar, restablecemos el certificado.

  1. En el caso de Apache:
    sudo certbot --apache
  2. Y para Nginx haremos lo propio:
    sudo certbot --nginx



Cron: el programador de tareas de Linux

Cron es un demonio (daemon) que funciona en segundo plano y ejecuta tareas automáticamente en un tiempo especificado por el usuario. Dichas tareas o trabajos (jobs), definidas generalmente en forma de scripts, se indican en un fichero de texto llamado crontab. Cada usuario del sistema posee su propio fichero crontab.

Veamos su funcionamiento mediante un ejemplo. Vamos a crear un script para que Raspberry Pi OS se actualice automáticamente cada cierto tiempo. Para ello, en el directorio del usuario (/home/pi) creamos un fichero llamado update.sh:

nano update.sh

Dentro del mismo escribimos lo siguiente:

#!/bin/bash
sudo apt update
sudo apt upgrade -y

Lo guardamos y a continuación le damos permisos de ejecución:

chmod u+x update.sh

Ahora lo añadimos como una nueva tarea de cron mediante la edición del fichero crontab:

crontab -e

Justo al final del fichero de texto que nos ha aparecido incluimos una línea para ejecutar nuestro script:

# m h dom mon dow       command
0 10 * * * /home/pi/update.sh > /dev/null 2>&1

NOTA: La parte final de la línea (> /dev/null 2>&1) se añade para que la ejecución del script no muestre ninguna salida por pantalla.

Una vez guardado el fichero, reiniciamos cron:

sudo service cron restart

Ahora tendremos una tarea que se ejecutará todos los días a las 10 de la mañana. Y para entender el funcionamiento de los 5 elementos (0 10 * * *) que hemos incluido al comienzo de esa línea, es preciso observar este esquema:

Podemos ver que, de izquierda a derecha, el significado de cada uno de esos 5 elementos es el siguiente:

min: minuto
hou: hora
dom: día del mes
mon: mes
dow: día de la semana

Podríamos cambiar la hora o los días en que queremos que se actualice el sistema operativo; para ello realizaremos las modificaciones oportunas, como en los siguientes ejemplos:

30 9 * * * /home/pi/update.sh > /dev/null 2>&1

Así, en lugar se ejecutarse todos los días a las 10, lo haría a la 9 horas y 30 minutos.

0 13 * * 5 /home/pi/update.sh > /dev/null 2>&1

Ahora la ejecución se llevaría a cabo todos los viernes (día 5 de la semana) a las 13 horas.

45 23 28 * * /home/pi/update.sh > /dev/null 2>&1

Con la línea anterior, se ejecutaría el día 28 de cada mes a las 23 horas y 45 minutos.

0 22 * * 1 /home/pi/update.sh > /dev/null 2>&1

En este último caso el sistema se actualizará los lunes (día 1 de la semana) a las 10 de la noche.


Intervalos de tiempo

Para indicar intervalos de tiempo se utilizan 3 caracteres especiales:

la coma		(,)   	separa una lista
el guión	(-)	indica un rango 
la barra	(/) 	cada cierto tiempo

Veamos algunos ejemplos:

0 10,15,19 * * * /home/pi/update.sh > /dev/null 2>&1

El script se ejecutará a las 10, a las 15 y a las 19 horas todos los días.

0 22 * * 1-5 /home/pi/update.sh > /dev/null 2>&1

Ahora lo hará a las 10 de la noche de lunes a viernes (días 1 al 5 de la semana).

0 */4 1,15 * * /home/pi/update.sh > /dev/null 2>&1

Se ejecutará cada 4 horas los días 1 y 15 de cada mes.

*/45 * * * * /home/pi/update.sh > /dev/null 2>&1

En este caso, la ejecución será cada 45 minutos.

0 9-23/2 * * 1,3,5 /home/pi/update.sh > /dev/null 2>&1

Por último, lo hará cada 2 horas (entre las 9 y las 23 horas) los lunes, miércoles y viernes.


Comandos específicos

  1. @reboot: se ejecuta en cada inicio del sistema.
  2. @yearly: se ejecuta una vez al año (0 0 1 1 *).
  3. @monthly: se ejecuta una vez al mes (0 0 1 * *).
  4. @weekly: se ejecuta una vez a la semana (0 0 * * 0).
  5. @daily: se ejecuta una vez al día (0 0 * * *).
  6. @hourly: se ejecuta una vez a la hora (0 * * * *).



Gestor de ficheros Midnight Commander

Quienes utilizaron hace varias décadas el sistema operatino MS-DOS, muy probablemente tenían instalado el famoso Norton Commander, una utilidad con la que era posible obviar la línea de comandos para usar en su lugar una pantalla dividida en dos partes que representaba el árbol de directorios. La aplicación permitía realizar las tareas más comunes con ficheros y carpetas (crear, copiar, mover, borrar, editar, renombrar,...) sin tener que aprenderse la lista de comandos, usando en su lugar un menú de opciones, las teclas de función, el tabulador, las flechas e incluso el ratón. Incluía además un editor de texto propio.

La gran popularidad de esta utilidad hizo que surgiera pronto una versión para el sistema operativo Linux. Por razones de copyright se le cambió el nombre a Midnight Commander y así, las siglas que se utilizaban para referirse al Norton, pasaron de NC a MC. Y de esta última forma es como se instala en la Raspberry Pi:

sudo apt install mc

La arrancamos con la misma abreviatura con la que la hemos instalado (mc para usarlo como usuario o sudo mc para acceder como administrador) y este será su aspecto:

Podemos cambiar a cualquiera de las dos partes en que se divide la pantalla con la tecla del tabulador o pinchando con el ratón. En el menú Opciones se nos ofrece la posibilidad de configurar una gran cantidad de detalles de esta práctica y veterana aplicación.



Instalar Docker y utilizar contenedores

Docker es una herramienta de virtualización muy ligera que permite correr aplicaciones y servicios utilizando contenedores. La virtualización basada en contenedores tiene una gran ventaja con respecto a los sistemas tradicionales como VMWare o Virtualbox: en los contenedores no se crea un sistema huésped completo, sino que las aplicaciones se encapsulan en módulos que comparten el mismo kérnel del sistema anfitrión y se ejecutan como procesos aislados en el espacio de usuario. Esto supone un gran ahorro de recursos: memoria, espacio de disco y uso de CPU. El hecho de que sea tan ligera implica que no requiere de un hardware potente, lo que la hace muy adecuada para su uso en una placa como la Raspberry Pi. Los contenedores son, además, sistemas autocontenidos que ya disponen de todo lo necesario (código, librerías, dependencias y ficheros de configuración) para poder funcionar en cualquier equipo.

Los creadores de esta plataforma mantienen un repositorio público en la nube, llamado Docker Hub, que contiene una enorme cantidad de imágenes de muchas de las aplicaciones y servicios más utilizados por usuarios y empresas de todo el mundo, ordenadas por categorías, sistemas operativos y arquitecturas (entre las que se encuentra ARM). Cualquiera puede crearse una cuenta (gratuita o de pago) e incluir su propio repositorio particular, haciéndolo público o privado.


Instalar Docker

Lo primero que haremos será actualizar la lista de paquetes de Raspberry Pi OS:

sudo apt update

A continuación ejecutamos el script que llevará a cabo la instalación:

sudo curl -sSL https://get.docker.com | sh

Para poder utilizarlo con el usuario habitual del sistema, añadimos éste al grupo de Docker:

sudo usermod -aG docker pi

y reiniciamos el equipo:

sudo reboot

Con el fin de comprobar que Docker está funcionando correctamente, ejecutamos un primer contenedor hecho ex profeso para esta finalidad: uno muy básico que simplemente muestra el típico "Hello World". Para ello usaremos esta orden:

docker run hello-world

Como podemos ver, la imagen del contenedor se busca primero localmente, y si no se encuentra (como es el caso), se descarga del repositorio Docker Hub. Después se ejecuta el contenedor, que muestra el mensaje Hello from Docker!, y a continuación es cuando se nos indica que la instalación se ha realizado correctamente.

Con los siguientes comandos conoceremos la versión de Docker que tenemos instalada y también otra información extendida (su directorio raíz, kérnel, arquitectura de la CPU, sistema operativo,...), respectivamente:

docker -v
docker info

Instalar Docker Compose

Ahora vamos a instalar Docker Compose, que es una extensión que nos permite gestionar varios contenedores a la vez, además de poder configurar de una forma más sencilla cómo se comunican entre ellos.

Primero instalamos el gestor de paquetes pip:

sudo apt install libffi-dev libssl-dev -y
sudo apt install python3-pip -y

Y luego instalamos la aplicación:

sudo pip3 install docker-compose

Para comprobar que todo ha ido bien, ejecutamos este comando para que nos muestre la versión:

docker-compose --version

Actualizar y desinstalar

Ambas herramienta se actualizan, respectivamente, mediante estos comandos:

sudo apt update && sudo apt upgrade
pip3 install --upgrade docker-compose

Para desinstalarlas, en el caso de Docker:

sudo apt remove --purge docker-ce
sudo rm -rf /var/lib/docker

Y en el caso de Docker Compose:

sudo pip3 uninstall docker-compose

Imágenes

Ya dijimos al principio que existe un gran repositorio donde se encuentran todas las imágenes disponibles para Docker, llamado Docker Hub. De aquí es de donde se descargan las imágenes que vamos a usar en nuestro sistema.

Podemos conocer la lista de comandos disponibles para trabajar con imágenes escribiendo esto:

docker image --help

Los más usados seguramente serán los siguientes:

docker image ls                                       Muestra la lista de imágenes
docker image rm nombre | ID                  Borra una imagen
docker image pull nombre                       Descarga una imagen del repositorio
docker image prune                                 Borra todas las imágenes

Los tres primeros comandos anteriores pueden abreviarse:

docker images
docker rmi nombre | ID
docker pull nombre

Hemos de tener en cuenta que no se puede borrar una imagen si ya existe un contenedor de la misma. Es necesario borrar previamente el contenedor, ya que este no es más que una imagen que se ha lanzado y se encuentra en ejecución.

Parar borrar una imagen podemos usar su nombre o bien su ID. En este último caso no es necesario teclearlo completo (sólo los primeros caracteres, siempre que no existan varios IDs que comiencen por los mismos caracteres). Así, si tenemos dos imágenes cuyos IDs son 6567cb064a414 y 639db11237ab2, respectivamente, para eliminar la primera basta con teclear docker rmi 65.


Contenedores

Como dijimos antes, un contenedor no es más que una imagen que se encuentra en ejecución realizando una tarea. Ello implica que para poder lanzar un contenedor, previamente ha de descargarse la imagen correspondiente: primero se comprueba si esta ya existe en la máquina local, y si no es así, se descarga automáticamente del repositorio.

Al igual que con las imágenes, podemos conocer la lista de comandos disponibles para trabajar con contenedores tecleando esto:

docker container --help

Los más usados en un principio son los siguientes:

docker run nombre                              Arranca un contenedor
docker run -d nombre                         Arranca un contenedor en segundo plano
docker run --name wp wordpress       Lo arranca asignándole un nombre (wp)
docker run -it ubuntu bash                  Arranca un nuevo contenedor y ejecuta comandos
docker exec -it nombre | ID bash        Ejecuta comandos en un contenedor ya arrancado
docker container rename nombre | ID nuevo_nombre               Renombra el contenedor
docker ps -a                                         Muestrra la lista de contenedores
docker stop nombre | ID                      Detiene un contendor
docker start nombre | ID                      Inicia un contendor parado
docker restart nombre | ID                   Reinicia (stop/start) un contendor
docker rm nombre | ID                         Borra un contendor (debe estar parado)
docker pause nombre | ID                    Pausa un contendor
docker unpause nombre | ID                Reinicia un contendor pausado
docker container prune                        Borra todos los contenedores

Como en el caso de las imágenes, para referirse a un contenedor por su ID, no hace falta escribirlo entero (sólo el/los primer/os caracteres, siempre que no existan varios IDs que comiencen por los mismos).




Montar un sistema de discos en RAID

El término RAID es un acrónimo que significa Redundant Array of Independent Disks o, dicho en español, matriz redundante de discos independientes. Se trata de crear un sistema para el almacenamiento de datos utilizando múltiples unidades, de forma que los datos se distribuyan entra ellas. Estas unidades de almacenamiento suelen ser discos duros mecánicos (HDD) o discos de estado sólido (SSD). El objetivo final del RAID es ofrecer al usuario una mayor capacidad de almacenamiento, redundancia de datos (para evitar la pérdida de estos) y proporcionar mayor velocidad de lectura y escritura que si solamente tuviéramos un único disco.

Existen diversos tipos y combinaciones de RAID. Los más utilizados son 0, 1, 5, 6, 01 (0+1) y 10 (1+0). Aquí vamos a ver únicamente los dos primeros, ya que son los más usados en entornos domésticos debido a su menor complejidad y a que se pueden configurar con sólo dos discos. Los demás tipos necesitan un mínimo de tres o cuatro discos.


RAID 0

También llamado conjunto dividido o striping, la función de este tipo de RAID es la de distribuir los datos entre los distintos discos que están conectados al equipo. Dichos datos se dividen en bloques que se reparten por todas las unidades de la matriz. Al utilizar varios discos (al menos 2) al mismo tiempo, ofrece un rendimiento de E/S superior, llegando casi a duplicar la velocidad de acceso. El objetivo de implementar un RAID 0 es el de proporcionar buenas velocidades de acceso a los datos que estén guardados en los discos, ya que la información esta equitativamente repartida en ellos para tener acceso simultáneo a una mayor cantidad de datos con los discos funcionando en paralelo. RAID 0 no tiene información de paridad ni redundancia de datos, por lo que si se rompe una de las unidades de almacenamiento, perderemos todos los datos que haya almacenados en la matriz.

Para realizar un RAID 0 debemos de prestar atención al tamaño de los discos que lo forman. En este caso será el disco de menor tamaño el que determine el espacio añadido en el RAID. Por ejemplo, si tenemos un disco de 1 TB y otro de 500 GB en la configuración, el tamaño del conjunto será de 1 TB, ya que el sistema usará el disco de 500 GB y otros 500 GB del disco de 1 TB. Por esto lo ideal es usar discos de igual tamaño para poder utilizar todo el espacio disponible en el conjunto.


RAID 1

Esta configuración también es llamada espejo o mirroring y es una de las más utilizadas debido a que proporciona redundancia de datos y buena tolerancia a fallos. En este caso, lo que estamos haciendo es crear un almacén con información duplicada en dos discos. Cuando guardamos un dato, este se copia inmediatamente en su unidad espejo para así tener dos veces el mismo dato almacenado.

Debido a que RAID 1 guarda los mismos datos en cada disco de la matriz, esto supone un aumento en la fiabilidad del sistema de almacenamiento: para que se pierdan los datos de un RAID 1, todas las unidades deben fallar al mismo tiempo. Cuando falla una unidad, el controlador muestra una advertencia que lo notifica. Al reemplazar la unidad defectuosa, el controlador reconstruye el nuevo disco con los datos almacenados en la otra unidad de forma automática. Esta seguridad tiene como contrapartida la pérdida de espacio de almacenamiento, pues de los dos discos (que deben ser del mismo tamaño), sólo aprovecharemos uno de ellos, ya que el otro se usa como copia del primero.

Conclusión: RAID 0 usa todo el espacio de almacenamiento y proporciona mayor velocidad, pero no tenemos ninguna seguridad en caso de fallo. RAID 1, en cambio, ofrece seguridad, pero a cambio de una menor velocidad y una pérdida de espacio de almacenamiento. De nosotros y de nuestras necesidades específicas dependerá el uso de uno u otro sistema. Para almacenar ficheros fácilmente recuperables (películas o software, por ejemplo) en caso de avería o fallo en alguno de los discos, podemos usar RAID 0 con el fin de tener disponible todo el espacio de ambos discos y ganar velocidad. Pero si vamos a guardar datos personales o críticos (fotos, vídeos, documentos) será preferible usar RAID 1, ya que en este caso prima la seguridad.


Instalar el software

En la Raspberry tenemos que crear el sistema RAID mediante software, para lo que necesitamos instalar la utilidad adecuada:

sudo apt install mdadm -y

Conectamos la dos unidades de disco USB a la Raspberry y tecleamos el siguiente comando:

lsblk

Obtendremos algo similar a lo que se observa en esta imagen:

Las dos unidades se muestran como sda1 y sdb1.


Crear el volumen

Ahora vamos a configurar el volumen RAID. En el caso de que queramos crear un RAID 0, teclearemos lo siguiente:

sudo mdadm --create --verbose /dev/md0 --level=0 --raid-devices=2 /dev/sda1 /dev/sdb1

Y en el caso de que deseemos crear un RAID 1, escribiremos esto otro:

sudo mdadm --create --verbose /dev/md0 --level=1 --raid-devices=2 /dev/sda1 /dev/sdb1

En ambos comandos, /dev/md0 es el nombre del volumen que queremos crear; con --level=0|1 elegimos el tipo de RAID; --raid-devices=2 indica el número de discos; y al final, separados por un espacio, se muestran las unidades de disco que se van a utilizar.

Ya que pretendemos guardar datos personales, vamos a optar por crear un RAID 1. Sea cual sea la opción elegida, se nos pedirá confirmación (Continue creating array?), así que respondemos Yes:

Al final se nos informa de la que matriz /dev/md0 se ha iniciado. Podemos comprobar que, efectivamente, se ha creado el RAID usando de nuevo este comando:

lsblk

que nos muestra ambas unidades de disco (sda1 y sdb1) apuntando a un único volumen de datos (md0).

Podemos obtener mucha información sobre el mismo con

sudo mdadm --detail /dev/md0

Formateo y montaje

Tenemos que dar formato al nuevo volumen RAID:

sudo mkfs.ext4 /dev/md0

Creamos la carpeta de montaje, le damos los permisos adecuados y montamos el volumen en ella:

cd /media
sudo mkdir raid
sudo chmod 777 raid
sudo mount /dev/md0 /media/raid

A continuación vamos a hacer que se monte automáticamente cada vez que iniciamos el sistema:

sudo nano /etc/fstab

Añadiremos al final de este fichero una nueva línea en la que indicaremos el nombre del dispositivo, la carpeta de montaje y el sistema de ficheros usado (los espacios se insertan con el tabulador):

/dev/md0    /media/raid    ext4    defaults    0    0

Guardamos los cambios y reiniciamos:

sudo reboot

A partir de este momento, para guardar, editar o descargar datos en nuestra unidad RAID podríamos instalar servicios como Samba o WebDAV, por ejemplo, utilizando en ellos la carpeta /media/raid como carpeta compartida y lugar de almacenamiento.




Crear un bot de Telegram

Gracias a la API de Telegram, se pueden crear bots para establecer una conexión con la la Raspberry Pi e interactuar con ella. En este apartado vamos a crear un bot sencillo que nos permiirá recibir diversas notificaciones:

  • Cuando se arranque o reinicie la RPi
  • En el momento en que alguien se conecte por SSH
  • Para indicarnos cuál es nuestra IP pública
  • Conocer la temperatura de la CPU

Naturalmente, lo primero que hemos de hacer es instalar Telegram en uno o en varios de nuestros dispositivos (PC, portátil, tableta, teléfono móvil). Como es habitual, para Android lo descargamos de Google Play; en el caso de iOS, de la App Store; y para instalarlo en un PC o portátil, podemos hacer clic en la imagen siguiente:


Creación del bot

Para crear nuestro propio bot tendremos que recurrir a @BotFather, que es el bot usado por Telegram para la creación de los mismos. Lo iniciamos y luego escribimos /newbot o lo seleccionamos del menú. Nos pedirá un nombre para el bot, así que escribimos el que nos parezca adecuado. A continuación nos pedirá que escribamos un nombre de usuario, que debe terminar en bot. Con esto ya está creado el bot, por lo que nos mostrará el token que vamos a necesitar luego para usar la API. Por último, necesitamos obtener nuestro identificador o ID de Telegram, que es único para cada usuario. Para conseguirlo, tenemos que iniciar un bot llamado @userinfobot, que nos lo mostrará.

Con el token y nuestro ID, volvemos al bot @BotFather y lanzamos el comando /mybots. Abrimos nuestro bot haciendo clic en él (aparecerá al final de Here it is: xxxxxxx@mibot) y lo iniciamos. Nos mostrará ya lanzado el comando /start y debajo del mismo es donde recibiremos las notificaciones.


Crear los scripts

Vamos a crear una serie de scripts en nuestra carpeta /home/pi para recibir notificaciones. Empezaremos por uno sencillo que nos muestre la temperatura de la CPU. Para ello, creamos un nuevo fichero que llamaremos, por ejemplo, así:

nano bot-temp.sh

Dentro del mismo vamos a añadir este contenido:

#!/bin/bash
TOKEN="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
ID="xxxxxxxxx"
MENSAJE="Temperatura de la RPi: $(/opt/vc/bin/vcgencmd measure_temp)"
URL="https://api.telegram.org/bot$TOKEN/sendMessage"
curl -s -X POST $URL -d chat_id=$ID -d text="$MENSAJE" > /dev/null 2>&1

En las dos primeras líneas, como es obvio, sustituimos las "xxxxxx" por nuestro TOKEN y nuestra ID, que obtuvimos más arriba.

Antes de lanzar el script, hay que hacerlo ejecutable:

chmod +x bot-temp.sh

Cada vez que lo ejecutemos (./bot-temp.sh), recibiremos una lectura de la temperatura en nuestro bot. Pero si queremos que se autoejecute, por ejemplo, un par de veces al día, recurriremos a cron. Para ello añadiremos una nueva tarea mediante la edición del fichero crontab:

crontab -e

Al final del todo incluiremos una línea para ejecutar el script dos veces al día (a las 15 y a las 23 horas):

0 15,23 * * * /home/pi/bot-temp.sh

Bien, a continuación vamos a crear un par de scripts más: uno para recibir un mensaje cuando se arranque o reinicie la Raspberry y otro para conocer su IP pública. Comenzamos con el primero:

nano bot-boot.sh

en el que pegaremos lo siguiente:

#!/bin/bash
TOKEN="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
ID="xxxxxxxxx"
MENSAJE="Ha arrancado la RPi"
URL="https://api.telegram.org/bot$TOKEN/sendMessage"
curl -s -X POST $URL -d chat_id=$ID -d text="$MENSAJE" > /dev/null 2>&1

Y este será el segundo:

nano bot-ip.sh

que tendrá un contenido ligeramente diferente:

#!/bin/bash
TOKEN="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
ID="xxxxxxxxx"
MENSAJE="IP pública de la RPi:  $(curl ifconfig.co)"
URL="https://api.telegram.org/bot$TOKEN/sendMessage"
curl -s -X POST $URL -d chat_id=$ID -d text="$MENSAJE" > /dev/null 2>&1

Al igual que antes, pondremos en las primeras líneas el TOKEN y el ID que obtuvimos cuando creamos el bot.

Ya sólo nos resta hacer ejecutables ambos ficheros:

chmod +x bot-boot.sh
chmod +x bot-ip.sh

Como hicimos más arriba con el primer script, vamos a lograr que también estos se autoejecuten durante el arranque o reinicio de la Raspberry, para lo que recurriremos a cron, añadiendo una nueva tarea mediante la edición del fichero crontab:

crontab -e

Al final del todo incluiremos una línea para ejecutar ambos scripts:

@reboot (sleep 30; /home/pi/bot-boot.sh; /home/pi/bot-ip.sh)

A partir de ahora, cada vez que se arranque o se reinicie la Raspberry, y una vez transcurridos 30 segundos (tiempo para que el sistema cargue todos los procesos necesarios antes de poder ejecutar el script), recibiremos dos mensajes en el bot:

Ha arrancado la RPi
IP pública de la RPi: xxxx.xxxx.xxxx.xxxx

Seguidamente, y por razones prácticas, en lugar de usar un script, recurriremos directamente a curl para lograr que se nos avise cuando alguien se conecta a la Raspberry por SSH. Resulta que cada vez que alguien inicia una sesión SSH en la terminal, el sistema lee el archivo .bashrc del usuario que se conecta. Así pues, lo editamos:

nano .bashrc

y al final del mismo pegamos la siguiente línea:

curl -s -X POST https://api.telegram.org/bot"TOKEN"/sendMessage -d chat_id="ID" -d text="Iniciada sesión SSH en la RPi desde la IP $(echo $SSH_CLIENT | awk '{ print $1}')" > /dev/null 2>&1

Sustituimos lo que aparece en negrita (TOKEN e ID) por los nuestros correspondientes y, una vez hechas estas modificaciones y guardados los cambios, si abrimos una sesión SSH, recibiremos en el bot este mensaje:

Iniciada sesión SSH en la RPi desde la IP xxx.xxx.xxx.xxx

NOTA: Si tenemos instalada la versión Desktop de Raspberry Pi OS (con la versión Lite no hay necesidad de hacerlo), debemos ir al escritorio (conectándonos directamente o por medio de VNC), desplegar el menú superior > Preferencias > Configuración de Raspberry Pi y en la pestaña Sistema, desmarcar (Disabled) el Ingreso automático. De no hacerlo, recibiremos en el bot la notificación de un inicio de sesión SSH nada más arrancar o reiniciar la Raspberry, aunque no nos hayamos conectado aún por SSH.




Establecer un portal cautivo

Vamos a convertir nuestra Raspberry en un punto de acceso inalámbrico (AP) y luego lo configuraremos para crear un portal cautivo u Hostpot. Este no es más que una página web que se abre automáticamente en el navegador del usuario cuando intenta acceder a Internet para visitar una web cualquiera. Por lo general debe completarse una acción antes de poder salir del portal cautivo. Se usa habitualmente en hoteles, bibliotecas o aeropuertos, por ejemplo, y suele ser necesario en estos casos introducir algún dato, como el email.

Nosotros lo vamos a utilizar para mostrar cierta información a los usuarios que se conecten a través del punto de acceso Wifi, que usará una subred separada dentro de nuestra LAN. De esta forma proporcionaríamos conexión a Internet, por ejemplo, a nuestros invitados, mostrándoles en el portal cautivo un mensaje de bienvenida o alguna información que consideremos relevante.


Creación del punto de acceso

En el menú correpondiente creamos un punto de acceso Tor. Aprovecharemos ahora lo que ya explicamos ahí. Para ello pulsamos en el enlace anterior y hacemos lo que se indica en los dos primeros subapartados:

  1. - REQUISITOS PREVIOS
  2. - CREAR EL PUNTO DE ACCESO (AP)

Configuración del portal cautivo

Realizados los dos pasos anteriores, tendremos funcionando un punto de acceso Wifi. Vamos a convertirlo ahora en un portal cautivo. Para ello debemos hacer varias cosas. En primer lugar, instalar estos dos paquetes:

sudo apt install git libmicrohttpd-dev

Después clonaremos el repositorio que contiene el código de Nodogsplash:

cd ~
git clone https://github.com/nodogsplash/nodogsplash.git

A continuación hay que compilarlo e instalarlo:

cd ~/nodogsplash
make
sudo make install

Ahora lo configuraremos:

sudo nano /etc/nodogsplash/nodogsplash.conf

El AP que creamos antes usa una subred con la dirección 10.3.141.1 por defecto, así que en el fichero de configuración de Nogdogsplash que estamos editando, le decimos que use esa dirección como Gateway, le indicamos el nombre de la interfaz wireless y añadimos un par de opciones más. Para ello buscaremos las siguientes líneas y sustituimos, cuando sea necesario, su contenido por este otro (o bien las comentamos con # y luego las pegamos así, todas juntas, al final del fichero):

GatewayInterface wlan0
GatewayAddress 10.3.141.1
MaxClients 250
AuthIdleTimeout 480

Lo ponemos en marcha con

sudo nodogsplash

y comprobamos que funciona conectándonos al AP. Si no lo hemos cambiamos antes durante su creación, el SSID será raspi-webgui. Cuando nos conectemos y abramos el navegador, nos aparecerá la web por defecto del Hotspot:


Personalizar el portal

Si queremos, podemos modificar la página web que se muestra por defecto, añadiendo o cambiando texto e imágenes. Para ello editamos este fichero:

sudo nano /etc/nodogsplash/htdocs/splash.html

Naturalmente, hemos de conocer el lenguaje HTML para hacer los cambios que consideremos oportunos y obtener un portal cautivo útil y estéticamente agradable.


Hotspot siempre listo

Para que Nodogsplash se active automáticamente siempre que reiniciemos la Raspberry, es necesario modificar este fichero:

sudo nano /etc/rc.local

Al final encontraremos la línea

exit 0

Pues bien, justo antes de esta línea final, añadiremos el comando que arranca el Hotspot:

nodogsplash

Por último, aclarar que, una vez hayamos pasado por el portal cautivo, ya no tendremos que volver a pasar por él hasta que no reiniciemos la Raspberry.