hits counter

Trucos:



Formatear y montar un disco duro USB

Para almacenar ficheros (por ejemplo, las descargas de Transmission) viene muy bien utilizar un disco duro externo USB (ya sea un HD o un SSD). Haciéndolo, evitaremos saturar la tarjeta SD tanto de datos como de carga de trabajo, aparte de poder llevar los ficheros de un ordenador a otro sin tener que apagar la Raspberry. Veamos el proceso para formatear y montar un HD/SSD en ella y hacer que se monte luego automáticamente cada vez que iniciemos el sistema.


Formateo

Lo primero que tenemos que hacer es conectar el HD a uno de los puertos USB y averiguar el nombre del dispositivo, es decir, el nombre que le asigna Linux (Raspberry Pi OS en este caso). Lo haremos con este comando:

sudo fdisk -l

Al final (en la parte de abajo de la pantalla) aparecerá el nombre. Si no tenemos ningún otro dispositivo USB conectado, muy probablemente será /dev/sda1. Las tres letras (sda) corresponden al nombre del dispositivo y el 1 indica el número de la partición. Lo normal es que sólo haya una partición (es decir, sda1) y así no tendremos que preocuparnos de nada más. Pero si no hay ninguna (en este caso sólo aparecerá sda), habrá que crear una partición; y en el caso de que haya varias (sda1, sda2, sda3,...), las eliminaremos todas y luego crearemos sólo una, como se muestra en los puntos 3, 4 y 5 de este apartado.

A continuación formatearemos el diso duro. Este proceso sólo puede realizarse si el dispositivo está desmontando, lo que significa que, si estuviera montando (en nuestro caso no lo está), habrá que desmontarlo previamente con el comando sudo umount /dev/sda1. Para usarlo con Raspberry Pi OS (o cualquier otra distribución de Linux) lo mejor es formatearlo con el sistema de ficheros ext4. Podemos realizar esto fácilmente desde la propia consola de comandos con la siguiente orden:

sudo mkfs.ext4 /dev/sda1

Montaje

Concluido el formateo, hay que crear un punto de montaje para nuestro HD, que será la carpeta desde la que accederemos a él. Para ello, crearemos un carpeta llamada, por ejemplo, hdusb dentro del directorio /media:

cd /media
sudo mkdir hdusb

En este momento ya podemos montar el disco duro en dicha carpeta con este comando:

sudo mount /dev/sda1 /media/hdusb

Pero para no tener que hacer esto cada vez que iniciemos el sistema, lo mejor es conseguir que se monte automáticamente al arrancar la Raspberry. Para lograrlo, tenemos que modificar el fichero /etc/fstab:

sudo nano /etc/fstab

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

/dev/sda1    /media/hdusb    ext4    defaults    0    0

Guardamos el fichero (Ctrl+o, Intro, Ctrl+x) y reiniciamos el sistema:

sudo reboot

A partir de ahora, cada vez que el sistema se inicie, el disco duro se montará automáticamente en la carpeta indicada.

Una vez hecho lo anterior, ya podemos crear todas las subcarpetas que necesitemos dentro de la carpeta /media/hdusb. Así pues, nos situamos en ella y creamos, por ejemplo, una carpeta para guardar los ficheros que descarguemos en nuestro sistema:

cd /media/hdusb
sudo mkdir descargas



Hacer backup de la tarjeta SD en Windows

Cuando tengamos la Raspberry configurada a nuestro gusto y todo funcione correctamente, es el momento perfecto de hacer un backup o copia de seguridad de la tarjeta SD. Así, si el sistema deja de funcionar bien o la tarjeta se estropea, podremos coger otra SD y volcar en ella la copia de seguridad, de manera que en unos minutos tendremos nuestro sistema funcionando de nuevo a la perfección.

Para ello emplearemos la utilidad Win32 Disk Imager, la misma con la que creamos la imagen del sistema Raspberry Pi OS en la tarjeta SD, y cuyo aspecto es el siguiente:

El proceso completo, paso a paso, lo haremos del siguiente modo:

  1. 1.) Insertamos la tarjeta SD de la Raspberry en el lector de tarjetas de nuestro PC.
  2. 2.) Creamos un fichero vacío con extensión img (por ejemplo, backupSD.img) en una carpeta del PC.
  3. 3.) Arrancamos el programa Win32 Disk Imager como administrador. Nos aparecerá la ventana de la aplicación, igual a la de la imagen anterior.
  4. 4.) En Device seleccionamos la letra de la unidad de la tarjeta SD. ¡Atención! Comprueba muy bien que has elegido correctamente la letra de la unidad o podrás formatear por error el disco duro.
  5. 5.) En Image File seleccionamos el fichero con extensión img que hemos creado en el paso 2.
  6. 6.) Pulsamos en el botón Read y empezará el proceso de copia de la imagen de la tarjeta SD en el fichero.
  7. 7.) Terminado el proceso, pulsamos en Exit para salir del programa.
  8. 8.) Ya sólo nos queda desmontar el lector y extraer la tarjeta SD.

En el fichero backupSD.img tendremos guardada ahora una imagen de la tarjeta SD tal y como estaba en el momento de hacer el backup, lista para recuperarla cuando lo necesitemos.




Hacer backup de la tarjeta SD desde la RasPi

Realizar una copia de seguridad de la tarjeta SD, con el sistema ya instalado y configurado a nuestro gusto, es algo que puede hacerse sin desconectar nuestra placa. Realizaremos la copia en un pendrive conectado a la RasPi y montado en /media/pen. En él hemos creado un directorio llamado backups para guardar las copias de seguridad. El proceso lo haremos desde la propia Raspberry, sin necesidad de apagarla ni salir de Raspberry Pi OS, y en sólo dos pasos:

Primero forzamos el desmontaje de las dos particiones de la tarjeta SD:

sudo umount -l /dev/mmcblk0p1 && sudo umount -l /dev/mmcblk0p2

Y luego hacemos el backup propiamente dicho. Para ello emplearemos el comando dd, que usa varios argumentos: if (el origen de la copia), of (el destino) y bs (el tamaño de los bloques):

sudo dd if=/dev/mmcblk0 of=/media/pen/backups/raspbian.img bs=1M

El proceso no muestra nada por pantalla y puede tardar bastante, dependiendo de la capacidad de la tarjeta SD. Para ver su evolución, podemos abrir otra sesión de SSH y escribir este comando:

sudo watch -n 10 kill -USR1 `pidof dd`

Entonces, en la primera sesión, el comamdo dd ya comenzará a mostrar la evolución del proceso de copia.

Una vez terminado, en el directorio /media/pen/backups tendremos una copia de seguridad del sistema (raspbian.img), lista para usar cuando la necesitemos. Para recuperarla, sólo tendremos que realizar de nuevo los dos pasos anteriores, teniendo en cuenta que en el segundo el proceso será inverso:

sudo umount -l /dev/mmcblk0p1 && sudo umount -l /dev/mmcblk0p2
sudo dd if=/media/pen/backups/raspbian.img of=/dev/mmcblk0 bs=1M



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 python-certbot-apache
  2. En el caso de Nginx:
    sudo apt install certbot python-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, por lo que es importante que sea un email válido, ya que 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 si queremos compartir nuestro email (Y/N). Finalmente se nos preguntará si deseamos o no redireccionar todas las peticiones (tanto las HTTP como las HTTPS) al protocolo HTTPS (No redirect/Redirect).

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

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

En principio no hay que preocuparse por la renovación: el paquete que instalamos antes se encarga de mantener nuestro certificado actualizado, ya que al instalar dicho el paquete, se instala también un timer de systemd que se ejecuta dos veces al día.

No obstante, si nuestra distribución no usa systemd o el timer no funciona correctamente por algún motivo, siempre 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

Por otro lado, podemos verificar el estado de nuestro certificado SSL 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



Conexión SSH mediante clave pública

Ya que habitualmente nos conectamos a la Raspberry Pi por medio de SSH, puede que nos interese hacerlo sin tener que recordar y teclear cada vez la contraseña. El truco consiste en generar un par de llaves (o claves), pública y privada, y copiar la primera en la RasPi, de manera que tenga constancia permanente de nuestra identidad y no nos pida la contraseña en cada conexión.

Si utilizamos alguna versión de Linux o de macOS en nuestro PC, el que usamos habitualmente para conectarnos por SSH, podremos generar las dos claves desde el mismo y enviar la clave pública a la Raspberry. Lo haremos de esta forma:

cd .ssh
ssh-keygen -b 2048 -t rsa -f id_rsa -P ""
ssh pi@192.168.1.33 < ~/.ssh/id_rsa.pub 'mkdir -p .ssh && cat >> .ssh/authorized_keys'

En las líneas anteriores lo que hemos hecho es ir al directorio oculto .ssh de nuestro PC, generar un par de claves RSA de 2048 bits y luego enviar a la Raspberry (cuya IP local es 192.168.1.33) la clave pública. A partir de ahora, para acceder por SSH, sólo tenemos que escribir esto:

ssh pi@192.168.1.33

y ya no será necesario escribir la contraseña.




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:





Enviar correos desde la línea de comandos

Ya que utilizamos la Raspberry casi siempre desde la terminal, en modo texto, puede que en algún momento nos interese enviar un correo a alguien sin tener que recurrir al modo gráfico, haciéndolo directamente desde la propia línea de comandos. Esto podremos conseguirlo fácilmente siguiendo los pasos que se indican a continuación.

Primero instalamos estos tres paquetes:

sudo apt install msmtp msmtp-mta mailutils

En segundo lugar creamos en el directorio /etc un fichero de configuración:

sudo nano /etc/msmtprc

e incluimos las siguientes líneas (en este caso, para un correo de Gmail):

account default
tls on
host smtp.gmail.com
port 587
from usuario@gmail.com
auth on
user usuario
password contraseña
tls_starttls on
tls_certcheck on
tls_trust_file /etc/ssl/certs/ca-certificates.crt

Lo que se ha destacado en negrita debemos cambiarlo, lógicamente, por los datos concretos de nuestra cuenta.

Guardamos los cambios (Ctrl+o, Intro, Ctrl+x) y a partir de ahora, cuando queramos enviar un correo, sólo tenemos que teclear lo siguiente:

echo "Texto del mensaje" | mail -s "Asunto" usuario@dominio.com

Si necesitamos enviar un mensaje más extenso, que incluya saltos de línea, tendremos que crear un archivo con el editor de textos. Por ejemplo:

nano correo.txt

Escribimos en este archivo el contenido del mensaje y lo guardamos. Después lo enviamos así:

cat correo.txt | mail -s "Asunto" usuario@dominio.com

Sea cual sea el método elegido, si además deseamos enviar el correo a varios destinatarios, sólo tenemos que separar al final las distintas direcciones de email por comas.




Cambiar el usuario por defecto

Raspberry Pi OS se instala con un usuario (pi) y su contraseña (raspberry) creados por defecto. Aquí indicamos cómo cambiar la contraseña, pero el nombre del usuario sigue siendo el mismo. Sin embargo, para obtener una mayor seguridad, podemos cambiar también el nombre del usuario.

MUY IMPORTANTE: Si deseamos hacer esto, el momento de hacerlo es justo después de instalar el SO y antes de instalar ninguna otra aplicación, pues estas podrían configurarse con el usuario por defecto, y al cambiar éste posteriormente, obtendríamos mensajes de error o problemas de funcionamiento.

Para realizar el cambio, será necesario habilitar la cuenta del administrador de los sistemas Linux, llamado root. Y para lograrlo, lo único que debemos hacer es asignale a éste una contraseña:

sudo passwd root

Alterar la seguridad

Como medida de seguridad, no se permite la conexión por SSH al usuario root, así que tendremos que cambiar la configuración para permitirle el acceso. Para ello, editamos el fichero de configuración del servidor SSH:

sudo nano /etc/ssh/sshd_config

Buscamos la variable PermitRootLogin y le cambiamos el valor a yes:

PermitRootLogin yes

Ahora reiniciamos el sistema:

sudo reboot
y entramos como root. Siendo administrador, ya podemos renombrar al usuario pi por un nuevo nombre de usuario (por ejemplo, jlopez) y mover todo el contenido de la carpeta personal de pi a la carpeta personal del nuevo usuario:

usermod -l jlopez pi -md /home/jlopez

Hacemos lo mismo con el grupo, cambiando el nombre del anterior por el nuevo:

groupmod -n jlopez pi

Efectuados todos los pasos anteriores, ya podemos reiniciar:

sudo reboot

y entrar con el nombre del nuevo usuario que hemos creado (jlopez), cuya contraseña será la misma que tenía el usuario pi.


Restablecer la seguridad

Para dejar las cosas como estaban inicialmente y evitar comprometer la seguridad del sistema, haremos dos cosas. Primero deshabilitamos al usuario root, para lo cual basta con eliminar su contraseña:

sudo passwd -l root                      [nos pedirá la contrasela de jlopez]

En segundo lugar, volvemos a editar el fichero de configuración del servidor SSH:

sudo nano /etc/ssh/sshd_config

e impedimos el acceso al administrador (aunque ya esté inhabilitado en el sistema) volviendo a asignar el valor no a la variable PermitRootLogin:

PermitRootLogin no

Sólo nos queda reiniciar el servidor para que el cambio surta efecto:

sudo service ssh restart

AVISO: Como medida de seguridad extra, el sistema nos pedirá que introduzcamos la contraseña del usuario cada cierto tiempo cuando hagamos uso del comando sudo.




Encender un ordenador con Wake on LAN

Si disponemos en casa de un PC al que necesitamos acceder de vez en cuando para guardar o descargar cosas, tenerlo encendido las 24 horas supondría un gasto energético elevado e innecesario. La solución más fácil y eficiente sería arrancarlo sólo cuando necesitemos acceder a él. Si estamos en casa, eso lo podemos hacer fácilmente. El problema es hacerlo a distancia, cuando estamos fuera de casa. Para realizarlo de este último modo necesitamos recurrir a Wake on LAN, que nos permite encender un ordenador por medio de su propio adaptador de red Ethernet. Aunque esto es posible hacerlo desde Internet (a través de una app del móvil, por ejemplo), resulta algo problemático, pues depende de ciertas características del router que no todos ellos poseen. Así pues, para obviar dichas complicaciones, lo haremos desde otro dispositivo de nuestra red local (LAN), como por ejemplo una Raspberri Pi.

Para llevar a cabo esta tarea de la forma indicada es preciso hacer tres cosas :

  1. 1.) Raspberry Pi: tener la RasPi siempre conectada (algo que podemos permitirnos debido a su bajo consumo energético) y accesible desde Internet.
  2. 2.) BIOS: que el ordenador que deseamos arrancar tenga la posibilidad de encendido a través de Wake on LAN y habilitar dicha opción en la BIOS del dispositivo. Para lograr esto, normalmente habrá que cambiar algunas opciones en la BIOS: dependiendo del modelo, puede que en el apartado ACPI o AHCI haya que activar el encendido de los dispositivos PCIe y luego habilitar el arranque mediante LAN. En otros modelos de BIOS puede que baste con activarlo en Opciones avanzadas -- Chipset Configuration -- Boot From Onboard LAN o algo similar. El manual de la placa nos será muy útil para averiguarlo en cada caso.
  3. 3.) Sistema Operativo: en el caso de que el PC que deseamos encender a distancia use Linux, no es necesario hacer nada más. En cambio, con Windows la cosa se complica. En este caso iremos al Panel de Control - Administrador de dispositivos - Adaptadores de red. Elegimos el adaptador Ethernet y con el botón derecho abrimos sus Propiedades. En la pestaña Opciones avanzadas buscamos una opción que diga "Activación con LAN apagado", "Reactivar con Magic Packet", "Remote wake-up", "Power up by LAN"... (o algo similar, dependiendo del fabricante del dispositivo) y la activamos. Luego vamos a la pestaña Administrador de energía y marcamos las casillas "Permitir que este dispositivo reactive el equipo" y "Permitir un Magic Packet para reactivar el equipo". Aceptamos y salimos.

Habiendo tenido en cuenta todo lo anterior, para enviar paquetes Wake on LAN deberemos instalar en la Raspberry el servicio correspondiente que se encargue de ello:

sudo apt install wakeonlan

El uso de este sistema es muy sencillo: accedemos a la RasPi por SSH y le pasamos la dirección MAC del ordenador de nuestra LAN que queremos encender. Entonces la Raspberry mandará un "paquete mágico" (magic packet) vía broadcast que será recibido por la máquina destino y se procederá a su arranque. Por ejemplo:

wakeonlan 0e:61:a2:37:4c:5f

En Linux, para conocer la dirección MAC de los adaptadores de red que posee un ordenador, podemos escribir el comando ifconfig. Si este comando no funciona, habrá que instalar previamente el paquete net-tools. En el caso de Windows escribiremos ipconfig /all en la ventana del Símbolo del sistema.

Finalmente, añadir que si queremos automatizar esta tarea para que la orden de encendido se ejecute, por ejemplo, todos los días a una determinada hora, podemos añadirla a cron, cuyo uso se explica detalladamente en el siguiente apartado.




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 * * * *).



Aumentar el tamaño de la memoria swap

La memoria swap (o memoria de intercambio, en español) la utiliza el sistema operativo, a modo de memoria auxiliar, cuando ha agotado toda la memoria RAM del sistema, reservando para ello una parte del espacio de la tarjeta microSD. Raspberry Pi OS, por defecto, sólo reserva 100 MB para este propósito. Esta cantidad es suficiente para la mayoría de los casos; pero en ocasiones, si instalamos muchas aplicaciones en nuestra Raspberry, puede quedarse escasa.

Para aumentar su tamaño editamos el correspondiente fichero de configuración:

sudo nano /etc/dphys-swapfile

Buscamos la línea CONF_SWAPSIZE=100 y escribimos al final la cantidad de memoria (en MBs) que deseemos. Por ejemplo:

CONF_SWAPSIZE=512

Para aplicar los cambios, podemos reiniciar el sistema (sudo reboot) o bien actualizar la propia swap. Si optamos por esto último, haremos lo siguiente:

sudo dphys-swapfile setup
sudo dphys-swapfile swapon

Comprobamos que los cambios se han aplicado correctamente con este comando:

cat /proc/meminfo | grep Swap

Con lo que obtendremos algo similar a esto:

SwapCached:                        0 kB
SwapTotal:                  524284 kB
SwapFree:                   524284 kB

Otra forma de comprobarlo es mediante el comando free, que nos muestra tanto el uso de la memoria RAM como de la memoria swap.




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. Aún así, lo mejor es probar y ver si funciona con nuestro HD. 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, hay que reiniciar el sistema para que se active el servicio:

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

hd-idle

Si la aplicación anterior no funciona en nuestro caso, entonces la desinstalamos (sudo apt purge hdparm) y probamos con hd-idle. Lo haremos en varios pasos, instalando primero varias 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 sda1

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 cambiamos estas dos líneas de la siguiente forma (indicando en la segunda los segundos que han de transcurrir 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



Mover el SO a un dispositivo USB

La Raspberry está diseñada para funcionar con el sistema operativo instalado en el lector de tarjetas microSD que incorpora. Pero podemos lograr que Raspberry Pi OS se ejecute también en un dispositivo USB. Para ello es necesario hacer una serie de modificaciones. Técnicamente lo que tenemos que hacer es cambiar de sitio la partición /dev/root de nuestro sistema (que se encuentra en la partición 2 de la tarjeta microSD) para que resida en el dispositivo USB externo. Lo haremos siguiendo estos pasos:

  1. 1.) Si ya tenemos una tarjeta microSD con el SO configurado y funcionando, vamos al paso 2. Si no es así, instalamos el SO en la tarjeta como se explica aquí, sin olvidar añadir después el fichero vacío ssh en la partición boot.
  2. 2.) Insertamos la tarjeta en la Raspberry; conectamos a ella el dispositivo USB (Pendrive, HD o SSD), la encendemos y accedemos por SSH (como también explicamos aquí).
  3. 3.) Escribimos el siguiente comando:
    sudo fdisk -l
    y nos aparecerá algo parecido a esto:

    En la imagen, /dev/mmcblk0p2 es donde se halla ahora el sistema operativo, mientras que /dev/sda es la unidad USB que hemos conectado.
  4. 4.) Vamos a preparar nuestro USB externo para copiar en él el sistema operativo, así que tecleamos esto:
    sudo fdisk /dev/sda
    En la línea de comandos pulsamos p para ver la lista de particiones y obtendremos esta imagen:

    Pulsamos d para borrar la primera partición (/sda1). Si hay más particiones, repetimos el proceso para borrarlas todas.
  5. 5.) A continuación pulsamos n para crear una nueva partición, luego p para que sea una partición primaria, escribimos 1 para indicar la primera partición y finalmente pulsamos Intro dos veces para aceptar los sectores inicial y final propuestos, con lo que la partición ocupará todo el espacio disponible en la unidad externa:

    Para salir y guardar los cambios, pulsamos w.
  6. 6.) Ahora formatearemos la partición que hemos creado:
    sudo mkfs.ext4 /dev/sda1
  7. 7.) Crearemos una carpeta en el directorio /media en la que montar la unidad USB:
    sudo mkdir /media/hdd
    Como en nuestro caso se trata de un disco duro, la hemos llamado hdd, pero podemos usar cualquier nombre que resulte identificativo.
  8. 8.) Montamos la partición en su carpeta:
    sudo mount /dev/sda1 /media/hdd
  9. 9.) Copiamos el contenido de la partición root (/) de la tarjeta microSD en la carpeta donde hemos montado la unidad USB:
    sudo rsync -avx / /media/hdd
  10. 10.) Editamos el fichero /etc/fstab de la unidad USB:
    sudo nano /media/hdd/etc/fstab

    y cambiamos la partición / de la microSD por la del dispositivo USB. Para ello, comentamos la partición 02 de la tarjeta y ponemos en su lugar /dev/sda1, como se muestra en la imagen:


  11. 11.) Finalmente modificaremos este fichero de la microSD:
    sudo nano /boot/cmdline.txt
    y sustituimos lo que hay justo a continuación de root= (que será la partición 02 de la tarjeta) por /dev/sda1, de manera que quede así (como se muestra en negrita):
    ... console=tty1 root=/dev/sda1 rootfstype=ext4 ...
  12. 12.) Guardamos los cambios y reiniciamos la Raspberry:
    sudo reboot

Con el comando df -h podremos ver que el SO (/dev/root) se encuentra ahora en la unidad USB, que se corresponde con la raíz /, mientras que la tarjeta (/dev/mmcblk0p1) contiene la partición de arranque /boot.

Como el disco duro externo incluye ahora la partición donde está instalado Raspberry Pi OS, es necesario que este dispositivo esté siempre conectado a la placa. Y lo mismo ocurre con la tarjeta microSD: hay que tenerla insertada para que se pueda realizar el arranque, pues la partición /boot, como hemos comprobado, se encuentra en la tarjeta.




Aumentar el amperaje de los puertos USB

Es posible aumentar la potencia eléctrica de salida de los puertos USB de la Raspberry Pi, lo que puede ser útil para conectar un disco duro, especialmente si es un disco de gran capacidad (más de 1 TB). Hacer esto es muy sencillo; tan sólo hemos de modificar un fichero:

sudo nano /boot/config.txt

y añadir esta línea al final:

max_usb_current=1

Guardamos los cambios y reiniciamos el sistema:

sudo reboot

De esta forma, el puerto USB dará 1,2A en lugar de 0,6A, que es lo que da defecto. Pero esos 1,2A se reparten entre los 4 puertos USB, así que para beneficiarse de esto, sólo debemos usar uno de ellos.

Aparte de este cambio, es imprescindible utilizar un cargador o fuente de alimentación que dé suficiente amperaje: mínimo 3A, y si es de 3,5A o 4A, mucho mejor.




Conexión remota mediante un cliente VNC

Si tenemos instalado Raspberry Pi OS Desktop, podremos acceder al escritorio y utilizar la Raspberry de forma gráfica mediante al servidor VNC que viene ya instalado y activado por defecto. No obstante, para comprobar que efectivamente el servidor está activado, vamos a entrar en la configuración del sistema escribiendo el siguiente comando:

sudo raspi-config

Aparecerá una ventana como la de la figura de abajo para configurar determinados aspectos del sistema:


En el apartado 5 Interfacing Options podremos activar/desactivar, entre otros servicios, el que corresponde al servidor VNC.

Para ponerlo en marcha, sólo tenemos que decirle cómo queremos usarlo, indicando el número del servidor, la resolución con la que deseamos que se muestre y la profundidad del color. Por ejemplo:

vncserver :1 -geometry 1920x1080 -depth 24

Como respuesta obtendremos un extenso mensaje al final del cual se nos indicará el nombre del servidor (hostname) y su IP local:

El nuevo escritorio es raspberrypi:1 (192.168.1.33:1)

Con estos datos ya podemos acceder a la Raspberry desde cualquier PC de nuestra red local utilizando un cliente VNC, en el que añadiremos una nueva conexión indicando cualquiera de los datos obtenidos antes: el hostname o la IP seguidos del número del servidor:

192.168.1.33:1

Para poder establecer la conexión se nos pedirá, como es habitual, el nombre de un usuario del sistema (pi) y su correspondiente contraseña.

En el caso de tener el cortafuegos ufw activado, será necesario abrir el puerto 5901/tcp. Y si además queremos tener acceso desde el exterior, necesitaremos instalar un sistema de DDNS y luego, en el router, redireccionar el mencionado puerto a la IP local de la Raspberry.