Instalar Ubuntu server en una tarjeta micro SD o pendrive USB para Raspberry Pi

Llevaba un tiempo intentando documentar el proceso de configuración de una Raspberry Pi como una cápsula de Time Machine, pero el artículo era demasiado largo. Cubre demasiada información y es difícil de leer.

Así que dividí las etapas en pasos más manejables. Esto tiene la ventaja de permitir que las fases comunes, como la configuración del sistema operativo, se compartan entre diferentes proyectos.

Por lo tanto, esta es la primera entrada. Otras profundizarán en cómo construir cosas diferentes a partir de esta primera imagen base.

Selección del sistema operativo

La versión de 64 bits de Raspberry Pi OS que probé no permite que ZFS se instale fácilmente. Ubuntu tiene la ventaja de ofrecer una experiencia similar independientemente de la plataforma, por lo que es mi opción preferida. Cualquier experiencia que adquieras con él será fácilmente transferible a otros sistemas con el mismo sistema operativo.

Puedes descargar imágenes de Ubuntu Server desde https://ubuntu.com/download/raspberry-pi. La versión LTS también es mi preferida.

El modelo Raspberry Pi determinará las versiones compatibles del sistema operativo.

ModeloUbuntu de 32 bitsUbuntu de 64 bits
Raspberry Pi 2CompatibleNo es compatible
Raspberry Pi 3CompatibleRecomendado
Raspberry Pi 4CompatibleRecomendado
Versiones de Ubuntu compatibles.

La Raspberry Pi 3 tiene beneficios limitados cuando se utiliza la imagen de 64 bits debido a su RAM. Además, no será compatible con ZFS por la misma razón. La Pi se reiniciará cuando se acceda a los volúmenes ZFS debido a la falta de RAM.

Si vas a usar una interfaz gráfica de usuario, deberías elegir una Raspberry Pi 4 con al menos 4 GB de RAM. Con la versión 22.04 de publicación imminente los requisitos creo que se han reducido a 2 GB.

La imagen se puede instalar directamente en una tarjeta micro SD:

# ddrescue -y -c 4Ki ubuntu-20.04.3-preinstalled-server-arm64+raspi.img /dev/sdxx

[o]

# dd if=ubuntu-20.04.3-preinstalled-server-arm64+raspi.img of=/dev/sdxx

Instalación del servidor Ubuntu en una memoria USB

Es posible arrancar desde una memoria USB, lo que es preferible por varias razones. Son más baratas, de más fácil acceso desde otro sistema y fáciles de reemplazar.

En primer lugar, activa el arranque USB en tu Pi.

ModeloSoporte de arranque USBNotas
Raspberry Pi 1No es compatiblen/a
Raspberry Pi 2 y 3BCompatibleDesde Raspberry Pi OS: echo program_usb_boot_mode=1 | sudo tee -a /boot/config.txt y reinicia.
Raspberry Pi 3B+CompatibleCompatible directamente.
Raspberry Pi 4CompatibleEn Raspberry Pi OS: rpi-eeprom-config --edit and set BOOT_ORDER=0xf41 y reinicia.
Raspberry Pi con arranque USB compatible.

Es posible que tengas que arrancar desde una tarjeta SD al menos una vez para configurar el arranque USB. Una vez activado, permanece activado para siempre.

Información adicional sobre los diferentes modos de arranque para la Raspberry Pi

Se proporcionan los siguientes enlaces como referencia.

Arranque de Raspberry Pi desde almacenamiento masivo USB https://www.raspberrypi.org/documentation/computers/raspberry-pi.html#booting-from-usb-mass-storage

Configuración del gestor de arranque Raspberry Pi 4

 https://www.raspberrypi.org/documentation/computers/raspberry-pi.html#raspberry-pi-4-bootloader-configuration

Flujo de arranque de Raspberry Pi 4
https://www.raspberrypi.org/documentation/computers/raspberry-pi.html#raspberry-pi-4-boot-flow

Pasos de configuración

Una vez configurado la Pi para arrancar desde un dispositivo USB, instala la imagen en una memoria USB con el mismo metodo que se hizo con la tarjeta SD.

# ddrescue -y -c 4Ki ubuntu-20.04.3-preinstalled-server-arm64+raspi.img /dev/sdxx

[o]

# dd if=ubuntu-20.04.3-preinstalled-server-arm64+raspi.img of=/dev/sdxx

Para que la imagen sea arrancable, tienes que hacer algunos cambios. He extraído los pasos de esta publicación del foro de Raspberry Pi. Puede que te resulte más fácil aplicar cambios si lo montas la memoria en otro sistema.

Hay dos opciones para hacer los cambios:

  • Montar la memoria USB en otro sistema y, a continuación, emitir los comandos en el dispositivo USB. Este otro sistema puede ser la propia Raspberry Pi arrancando desde la tarjeta SD y accediendo al dispositivo USB.
  • O hacer los cambios en la tarjeta SD y, a continuación, copiar la imagen de la tarjeta SD en el dispositivo USB.

Haz los siguientes cambios en la memoria USB.

1) En el /boot del dispositivo USB, descomprime vmlinuz.

$ cd /media/*/system-boot/
$ zcat vmlinuz > vmlinux

2) Actualiza el archivo config.txt. La sección pi4 se muestra en este ejemplo, pero también se ha probado en un Pi 3. Solo tienes que introducir la información de tu modelo Pi.

$ vim config.txt

La línea dtoverlay puede ser opcional para los sistemas sin monitor, pero si tienes el tiempo y la inclinación, hay alguna documentación sobre los parámetros del árbol de dispositivos de Raspberry Pi.

[pi4]
kernel=vmlinux
max_framebuffers=2
dtoverlay=vc4-fkms-v3d
boot_delay
initramfs initrd.img followkernel

3) Crea un script en la partición de arranque llamado auto_decompress_kernel con el siguiente contenido:

#!/bin/bash -e

## Set Variables

BTPATH=/boot/firmware
CKPATH=$BTPATH/vmlinuz
DKPATH=$BTPATH/vmlinux

## Check if compression needs to be done.

if [ -e $BTPATH/check.md5 ]; then
	if md5sum --status --ignore-missing -c $BTPATH/check.md5; then
    	echo -e "\e[32mFiles have not changed, Decompression not needed\e[0m"
	    exit 0
	else
        echo -e "\e[31mHash failed, kernel will be compressed\e[0m"
	fi
fi

# Backup the old decompressed kernel

mv $DKPATH $DKPATH.bak

if [ ! $? == 0 ]; then
	echo -e "\e[31mDECOMPRESSED KERNEL BACKUP FAILED!\e[0m"
	exit 1
else
    echo -e "\e[32mDecompressed kernel backup was successful\e[0m"
fi

#Decompress the new kernel
echo "Decompressing kernel: "$CKPATH".............."

zcat $CKPATH > $DKPATH

if [ ! $? == 0 ]; then
	echo -e "\e[31mKERNEL FAILED TO DECOMPRESS!\e[0m"
	exit 1
else
	echo -e "\e[32mKernel Decompressed Succesfully\e[0m"
fi

# Hash the new kernel for checking
md5sum $CKPATH $DKPATH > $BTPATH/check.md5

if [ ! $? == 0 ]; then
    	echo -e "\e[31mMD5 GENERATION FAILED!\e[0m"
	else
        echo -e "\e[32mMD5 generated Succesfully\e[0m"
fi

# Exit
exit 0

Normalmente tendrías que marcar el script como ejecutable, pero a menos que modifiques la partición de su valor predeterminado FAT32, no hay ningún indicador ejecutable que establecer. Así que déjalo como está.

Si puedes montar el sistema de archivos raíz en el sistema que estás utilizando para editar los archivos, puedes seguir adelante con los pasos 4 y 5. De lo contrario, deberías poder arrancar ahora y realizar manualmente estos pasos después de tu primer arranque.

4) Crea un script en el directorio /ect/apt/apt.conf.d/ y llámalo 999_decompress_rpi_kernel

# cd /media/*/writable/etc/apt/apt.conf.d/
# vi 999_decompress_rpi_kernel

Rellena el archivo con el siguiente contenido:

DPkg::Post-Invoke {"/bin/bash /boot/firmware/auto_decompress_kernel"; };

5) Haz que el script sea ejecutable.

# chmod 744 999_decompress_rpi_kernel

Puedes ahorrarte algo de tiempo y configurar la red ahora.

En mi caso, tengo una cesión DHCP fija asociada a la dirección MAC de mi Pi, pero si no es tu caso, puedes configurar la red con una dirección IP fija editando el archivo de configuración de red en /boot.

$ cd /media/*/boot/
$ vim network-config

Un ejemplo de entrada de dirección IP fija sería:

version: 2
ethernets:
  eth0:
    dhcp4: no
    addresses: [192.168.1.201/24]
    gateway4: 192.168.1.254
    nameservers:
       addresses: [192.168.1.254]

Puedes expulsar la unidad USB, insertarla en tu Raspberry Pi y arrancar.

Configuración de Ubuntu

El nombre de usuario y la contraseña predeterminados son ubuntu / ubuntu.

Al iniciar sesión, se te pedirá que cambies la contraseña. Eliminaremos a este usuario por defecto en los siguientes pasos para aumentar la seguridad.

Ejecutar una actualización:

$ sudo su
# apt update -y
# apt upgrade -y

Configuración de usuarios

Crea un nuevo usuario (o cambia el nombre del usuario existente).

# adduser <nuevo_usuario>

Extrae los grupos para el usuario ubuntu y compáralos con el nuevo usuario.

# id ubuntu ; echo ; id <nuevo_usuario>

uid=1000(ubuntu) gid=1000(ubuntu) groups=1000(ubuntu),4(adm),20(dialout),24(cdrom),25(floppy),27(sudo),29(audio),30(dip),44(video),46(plugdev),115(netdev),118(lxd)

uid=1001(newuser) gid=1001(newuser) groups=1001(newuser)

Añade el nuevo usuario a los mismos grupos.

# usermod -a -G adm,dialout,cdrom,floppy,sudo,audio,dip,video,plugdev,netdev,lxd <nuevo_usuario>

Nombre del sistema

Establece el nombre del sistema.

# hostnamectl set-hostname <nombre_del_sistema>    

[Comprueba el cambio]

# hostnamectl
   Static hostname: pi-capsule
         Icon name: computer
        Machine ID: db0a1818241a47e178f229294f6864ae
           Boot ID: 983818fbaa8246348066c36f2237636e
  Operating System: Ubuntu 20.04.2 LTS
            Kernel: Linux 5.4.0-1029-raspi
      Architecture: arm64

Fecha y hora

Establece la zona horaria.

# timedatectl set-timezone Europe/Madrid

Configura las fuentes de tiempo editando /etc/systemd/timesyncd.conf.

[Time]
NTP=es.pool.ntp.org
FallbackNTP=ntp.ubuntu.com

Reinicia el servicio.

# systemctl restart systemd-timesyncd.service

Comprueba el estado y comprueba que la fuente de tiempo es correcta.

# systemctl status systemd-timesyncd.service

Por último, comprueba que la zona horaria es correcta.

# timedatectl status
               Local time: Sun 2021-08-29 23:24:49 CEST
           Universal time: Sun 2021-08-29 22:24:49 UTC
                 RTC time: n/a                        
                Time zone: Europe/Madrid (CEST, +0100) 
System clock synchronized: yes                        
              NTP service: active                     
          RTC in local TZ: no

Personalización del Mensaje del Dia

Puedes obtener el MOTD desde la pantalla de inicio de sesión manualmente con el siguiente comando.

$ for i in /etc/update-motd.d/* ; do if [ "$i" != "/etc/update-motd.d/98-fsck-at-reboot" ]; then $i; fi; done

Para obtener información del sistema (incluida la temperatura):

$ /etc/update-motd.d/50-landscape-sysinfo

Puedes editar, añadir y reordenar scripts en /etc/update-motd.d/.

Configuración de SSH

SSH se habilita de forma predeterminada. Prueba el acceso con la cuenta recién creada.

De forma predeterminada, solo se requiere la contraseña para acceder al servidor, pero añadiremos el requisito de necesitar una clave SSH con la contraseña. Y también deberias de limitar el acceso a direcciones IP autorizadas.

Necesitas tener un par de claves públicas y privadas en el ordenador que vayas a usar para acceder remotamente a la Pi.

Una breve nota sobre el cifrado. La criptografía de curva elíptica (ECC) genera claves más pequeñas y proporciona un cifrado más rápido que el no ECC. Las claves ECC más pequeñas también proporcionan un nivel equivalente de cifrado proporcionado solo con claves RSA más grandes:

Tamaño de la clave ECCEquivalente RSA
160 bits1024 bits
224 bits2048 bits
256 bits3072 bits
384 bits7680 bits
512 bits15360 bits
ECC utiliza claves más pequeñas con mayor seguridad equivalente.

Puedes usar las teclas ECDSA o ED25519. ED25519 es relativamente nuevo, por lo que es posible que algunos clientes muy antiguos no lo admitan, pero es el más rápido y seguro.

Para ambos tipos de cifrado, se recomienda utilizar el tamaño de clave más grande. Esto es de 521 bits para ECDSA (ten en cuenta que 521 no es un error tipográfico). Las claves ED25519 tienen una longitud fija de 512 bits.

Cuando ejecutes ssh-keygen, utiliza la opción -o. Esto fuerza el uso del nuevo formato OpenSSH (en lugar de PEM) para guardar tu clave privada. Aumenta la resistencia a un conocido ataque de fuerza bruta. Rompe la compatibilidad con las versiones de OpenSSH anteriores a 6.5, pero esta versión de Ubuntu lleva la versión 8.2, por lo que esto no es un problema.

Más información sobre la generación de claves SSH está disponible aquí: https://www.ssh.com/ssh/keygen/

Los pasos son:

Crea un par de claves con:

$ ssh-keygen -o -t ed25519

[o]

$ ssh-keygen -o -t ecdsa -b 521

Copia la clave pública en el servidor de Ubuntu. Se puede hacer manualmente, pero lo mejor es utilizar la herramienta dedicada a ello:

$ ssh-copy-id -i ~/.ssh/<clave_privada> <usuario>@<sistema_remoto>

Ten en cuenta que utiliza el parámetro -i con la clave privada, y ssh-copy-id enviará la clave pública para su almacenamiento en el sistema remoto.

SSH se puede configurar en el servidor para permitir solo inicios de sesión con contraseña, solo inicios de sesión con clave, o para requerir ambos.

# vim /etc/ssh/sshd_config

PasswordAuthentication no” solo usará la clave, y “PasswordAuthentication yes” usará tanto la contraseña como la clave. Obviamente, la segunda opción es más segura.

También desactivamos la opción de permitir que root inicie sesión a través de SSH. root está desactivado en la imagen de forma predeterminada, pero asegúrate de que SSH se haya configurado correctamente de todos modos.

PermitRootLogin no
PasswordAuthentication yes
# systemctl restart sshd

SSH desde otro terminal con la nueva cuenta de usuario y asegúrate de que el acceso funciona.

Si funciona, elimina la antigua cuenta de ubuntu.

# userdel -r ubuntu

Activar y configurar el cortafuegos

Establece reglas predeterminadas base (denegar todo lo entrante, permitir todo lo saliente).

# ufw status

# ufw default allow outgoing

# ufw default deny incoming

UFW requiere que IPv6 esté habilitado. Se puede hacer que funcione con él desactivado, pero cómo lograrlo está fuera del alcance de esta publicación.

# vim /etc/default/ufw

IPV6=yes

Permitir SSH.

# ufw allow ssh

[Pero preferiblemente permite sólo clientes específicos:]

# ufw allow proto tcp from <CLIENTE> to <SERVIDOR> port 22

Y limita los intentos de conexión permitidos para frustrar los ataques de fuerza bruta:

ufw limit ssh

Activa el cortafuegos y comprueba las reglas:

# ufw enable

# ufw status

[Lista las reglas con números]

# ufw status numbered

Recuerda que si utilizas IPv6, es posible que tengas que editar las reglas en consecuencia.

Instalar log2ram

Para reducir el número de escrituras en la unidad USB/tarjeta SD, puedes utilizar la utilidad de disco RAM log2ram.

Descargar Log2ram

No solo eso, sino que acelerará el rendimiento de la Raspberry Pi a cambio de una pequeña cantidad de RAM.

Instalar:

# echo "deb http://packages.azlux.fr/debian/ buster main" | sudo tee /etc/apt/sources.list.d/azlux.list

# wget -qO - https://azlux.fr/repo.gpg.key | sudo apt-key add -

# apt update -y

# apt install log2ram

Configura el servicio. La entrada SIZE depende del sistema; 256M es mucho para una Pi con solo 1 GB de RAM. Puedes reducirlo a una cantidad que sea mas adecuada., como por ejemplo, 64M.

# vim /etc/log2ram.conf

SIZE=256M
USE_RSYNC=true
MAIL=true
PATH_DISK="/var/log"

Y reinicia.

# reboot

Comprueba que el servicio funciona:

$ systemctl status log2ram
$ df -h | grep log2ram
log2ram         256M  106M  151M  42% /var/log

Instalación de utilidades adicionales

Instala las aplicaciones que desees. Estas con algunas que me gustan a mi.

# apt install mosh tmux pydf vim-nox glances iotop

Mosh puede requerir que se abran algunos puertos en el cortafuegos.

El rango de puertos van de 60001 a 60999, pero si esperas pocas conexiones, puedes hacer que el rango sea más pequeño.

# ufw allow proto udp from <SOURCE> to <SERVER> port 60001:60010

# ufw limit 60001:60010/udp

Instalar Cockpit

# apt install -y cockpit
# ufw allow proto tcp from <SOURCE> to <SERVER> port 9090

# ufw limit 9090/tcp

Ahora se puede acceder al sistema a través del navegador web a través del puerto 9090:

https://[sistema/IP]:9090

Aliases

En Ubuntu, y en la mayoría de las distribuciones, habrá una entrada en ~/.bashrc que se verá así:

if [ -f ~/.bash_aliases ]; then
. ~/.bash_aliases
fi

Esta entrada se puede añadir manualmente si no está presente. Esto permite agrupar todos los alias en ~/.bash_aliases.

$ vim ~/.bash_aliases
# Muestra RAM libre
alias showfreeram="free -m | sed -n '2 p' | awk '{print $4}'"

# Libera RAM
# alias freeram='freeram && sync && sudo echo 3 | sudo tee /proc/sys/vm/drop_caches && freeram -m'

# Muestra temperatura
alias temp='cat /sys/class/thermal/thermal_zone0/temp | head -c -4 && echo " C"'

# Muestra datasets de ZFS y ratio de compresión
alias ratio='sudo zfs get all | grep " compressratio "'

Esto crearía una imagen base con un nivel de seguridad decente. Es probable que añada cómo añadir Fail2Ban para mejorar aún más la seguridad.

Artículo traducido por Alf de mi versión original en Pov.es

¿Te ha gustado este artículo? ¿Querrías que publicáramos más? ¡Deja un comentario!

5 1 vota
Article Rating
Subscribe
Notify of
0 Comments
Opiniones Inline
Ver todos los comentarios

Lost your password? Please enter your email address. You will receive mail with link to set new password.

wpDiscuz
0
0
Me encantaría saber tu opinión, por favor, deja un comentariox
()
x