Buenas
Lo prometido es deuda. Hace algún tiempo, mas del que me gustaría dije que escribiría un articulo sobre como instalar Arch GNU/Linux con un sistema de particiones lógicas mediante volúmenes lógicos LVM, cifrados con dm-crypt y LUKS, sobre discos duros con particiones RAID1 por software.
Básicamente lo que vamos a hacer es lo que se muestra en la imagen. Sobre los discos físicos crearemos unas particiones de tipo linux-raid, y montaremos unos dispositivos virtuales RAID1 por software. Estos dispositivos RAID, los cifraremos con dm-crypt y LUKS, y dentro de los volúmenes cifrados, crearemos un sistema LVM donde crearemos los volúmenes lógicos necesarios para todas nuestras particiones.
Así a bote pronto, todo esto puede parecer muy complicado, pero una vez que lo hagáis veréis que realmente es muy sencillo.
Asumiré que todos sabéis bajaros la ISO de Arch Linux desde la pagina oficial, grabarla en un CD o USB y arrancar vuestro PC desde ella. Y por supuesto, que habéis echo una copia de seguridad de todo aquello que no queréis perder.
Una vez arrancado el sistema Live de Arch Linux, comenzamos a tirar comandos.
Los primeros pasos son para configurar el entorno de instalación.
1 2 3 4 5 6 |
# loadkeys es # setfont Lat2-Terminus16 # nano /etc/locage.gen # locale-gen # export LANG=gl_ES.UTF-8 # ping -c3 lignux.com |
Lo que hacemos con estos comandos es cargar la disposición del teclado en español, poner una fuente que se vea algo mejor, escoger las locales que nos interesa usar, por ejemplo: gl_ES.UTF-8, es_ES.UTF-8 y en_GB.UTF-8. Generamos las locales seleccionadas y exportamos en la variable de sistema LANG la que queramos por defecto. Por ultimo comprobamos que tenemos conexión.
Y entramos en faena. Para este ejemplo voy a asumir que tenemos cuatro discos, dos de 500GB y dos de 1TB, y que nuestro ordenador tiene firmware BIOS, no UEFI.
Para las particiones vamos a usar el sistema de particonado GPT en lugar del ya prácticamente obsoleto msdos. E instalaremos el gestor de arranque Grub.
Por ello, lanzamos el programa cgdisk indicándole sobre que disco queremos trabajar.
1 |
# cgdisk /dev/sda |
Se nos mostrara una pantalla similar a esta:
1 2 3 4 5 6 7 8 9 |
cgdisk 1.0.1 Disk Drive: /dev/sda Part. # Size Partition Type Partition Name ---------------------------------------------------------------- 500.0 GiB free space [ Align ] [ Backup ] [ Help ] [ Load ] [ **New** ] [ Quit ] [ Verify ] [ Write ] |
Moviendo de arriba a abajo podemos seleccionar entre los diferentes espacios en el disco, en este momento solo uno de 500GB libres. Moviendo de izquierda a derecha escogeremos entre las opciones del menú inferior.
Pulsamos New.
Se nos pregunta el sector inicial de la nueva partición. Dejamos el sugerido.
Se nos pregunta el tamaño de la partición. Indicamos +1M.
Se nos pregunta el tipo de partición que va a ser. Con L podemos ver los diferentes tipos. Indicamos ef02 (biosgrub).
Esta primera partición (sda1) de 1MB es necesaria precisamente porque estamos usando GPT con GRUB en firmware BIOS. Realmente no estoy al 100% seguro de si es necesaria, porque veréis que cgdisk ya deja 1007KB libres al principio del disco, pero por si acaso, la creamos.
Nos movemos al espacio libre al final del disco y repetimos el proceso creando dos particiones mas. Aceptamos el sector inicial sugerido para cada una, la primera de tamaño +1G (sda2), la segunda de tamaño +476472M (sda3), ambas de tipo fd00 (linuxraid).
Veréis que al final del disco siguen quedando unos 100MB libres, aproximadamente. Y os preguntareis porque puse ese tamaño tan raro en lugar de aceptar la sugerencia del programa y coger todo el espacio libre que quedaba.
No todos los discos ocupan lo mismo, y si particionaramos hasta el final del disco, cuando montemos los discos en RAID no estamos 100% seguros de que las particiones tengan exactamente el mismo tamaño. Al dejar el final del disco libre, nuestras particiones serán iguales independientemente de si uno de los discos es unos pocos Megas mas grande que el otro.
Con este esquema de particionado creado, escogemos la opción de Write, y los cambios se graban al disco. Ahora podríamos hacer lo mismo con el disco /dev/sdb, pero es mucho mas cómodo, copiar el esquema de particionado de un disco a otro, por lo que ejecutamos:
1 2 |
# sgdisk /dev/sda -R=/dev/sdb # sgdisk -G /dev/sdb |
Con el segundo comando nos aseguramos de que regenere los UUIDS del segundo disco para que no sean los mismos del primero.
Repetimos el proceso para el disco /dev/sdc y creamos un esquema de particionado de una sola partición de todo el espacio libre menos 100MB al final, sin necesidad de dejar la partición de 1MB al principio, de tipo fd00 (linuxraid) (sdc1). Copiamos este esquema de particionado al disco /dev/sdd.
Ya con los cuatro discos particionados, vamos a crear los dispositivos RAID.
Los dispositivos RAID de tipo 1, como el que vamos a crear, son dos discos, o mas, en paralelo, sobre los que se escribe a la vez. Por lo que si en uno se producen errores físicos y hay que tirarlo, no perdemos los datos ya que están en el otro. Al remplazar el disco averiado, el otro disco se sincronizara con el nuevo. Con esto evitaremos en buena cantidad de riesgo para nuestros discos.
Ejecutamos:
1 2 |
# modprobe raid1 # mdadm --create --verbose --level=1 --metadata=1.2 --chunk=64 --raid-devices=2 /dev/md0 /dev/sda2 /dev/sdb2 |
Con esto le estamos indicando que nos cree un dispositivo RAID de tipo 1, de 2 discos, con nombre md0 formado por las particiones sda2 y sdb2.
Repetimos el proceso con las parejas sda3 y sdb3, y sdc1 y sdd1 con los nombres md1 y md2.
Una vez creados los dispositivos, no debemos continuar, pues aunque estén vacíos, deben sincronizarse entre ellos, y esto puede llevarles un rato largo. Para ver el estado de sincronización ejecutamos:
1 |
# watch -n1 cat /proc/mdstat |
Cuando la sincronización haya finalizado, podemos ver la información de los dispositivos raid con el comando:
1 |
# mdadm --misc --detail /dev/md[012] | less |
Ahora que tenemos tres dispositivos virtuales RAID1, vamos a cifrar dos de ellos. El md0 (originalmente sda2), donde alojaremos la partición /boot, no puede estar cifrada, ya que GRUB no sabría que hacer con ella.
Ejecutamos los comandos:
1 2 3 |
# modprobe dm-crypt # cryptsetup -v --cipher aes-xts-plain64 --key-size 512 --hash sha512 --iter-time 5000 --use-random luksFormat /dev/md1 # cryptsetup -v --cipher aes-xts-plain64 --key-size 512 --hash sha512 --iter-time 5000 --use-random luksFormat /dev/md2 |
Con esto crearemos un cifrado de tipo aes-xts-plain64, con una llave de 512bits, en formato LUKS.
Una vez creado el cifrado, debemos abrirlo para que nos permita utilizar los dispositivos. Para esto ejecutamos:
1 2 |
# cryptsetup open --type luks /dev/md1 md1-crypt # cryptsetup open --type luks /dev/md2 md2-crypt |
Con este comando indicamos que nos abra para utilización dos dispositivos de tipo luks, con los nombres md1-crypt y md2-crypt. Podéis ponerle los nombres que queráis.
Ahora que tenemos nuestros dispositivos RAID cifrados y disponibles para su uso, dentro de ellos vamos a montar un sistema LVM para gestionar volúmenes lógicos, que vendrían a ser similares a las particiones, pero sin algunas restricciones de las mismas. Por ejemplo podríamos crear un volumen lógico, que se expanda en dos discos a la vez, algo que no podemos hacer con una partición tradicional.
Otra de las ventajas de los sistemas LVM es que no es necesario que el espacio de un mismo volumen esta a continuación en el disco. En un sistema tradicional de particiones, si creamos tres particiones: sda1, sda2, sda3, y en un determinado momento borramos sd3, o directamente queda espacio libre después de esta, no podríamos indicarle a sda1 que se extienda ocupando ese espacio, ya que están las otras particiones en el medio. Con LVM no tenemos este problema.
Al tener los dispositivos cifrados, esto nos limita a que nuestros grupos de volúmenes LVM solo comprendan un único dispositivo cifrado. Es por esto que en nuestro caso debemos de crear dos.
El primer paso es indicar cuales de las particiones de nuestros discos se podrán utilizar para el sistema LVM, y para ello crearemos un volumen
físico para cada uno de nuestros dispositivos RAID1 cifrados.
1 2 3 |
# modprobe dm-mod # pvcreate /dev/mapper/md1-crypt # pvcreate /dev/mapper/md2-crypt |
A continuación creamos los grupos de volúmenes.
1 2 |
# vgcreate Sistema /dev/mapper/md1-crypt # vgcreate Datos /dev/mapper/md2-crypt |
Y por ultimo, creamos los volúmenes lógicos dentro de nuestros grupos.
1 2 3 4 5 6 7 8 |
# lvcreate -L 20G Sistema -n root # lvcreate -L 3G Sistema -n swap # lvcreate -L 20G Sistema -n var ... # lvcreate -L 3G Datos -n swap2 # lvcreate -L 500G Datos -n home ... # lvcreate -l +100%FREE Datos -n srv |
Podemos crear tantos volúmenes lógicos como queramos, e incluso no utilizar todo el espacio libre para poder ampliar en un futuro alguno de los existentes, siempre que permanezcamos dentro del dispositivo cifrado. Es recomendable, aunque no obligatorio, crear un volumen lógico en cada disco físico que se este usando.
Podemos ver la información sobre nuestro sistema LVM con los comandos:
1 2 3 |
# pvdisplay # vgdisplay # lvdisplay | less |
Ahora que ya tenemos nuestro esquema de particiones completo, con dispositivos RAID cifrados y el sistema LVM dentro, nos toca crear los sistemas de ficheros, montar las particiones e instalar Arch GNU/Linux propiamente.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
# mkfs.ext4 /dev/mapper/Sistema-root # mkfs.ext4 /dev/mapper/Sistema-var # mkfs.ext4 /dev/mapper/Sistema-home # mkfs.ext4 /dev/mapper/Datos-srv # mkfs.ext4 /dev/mapper/... # mkswap /dev/mapper/Sistema-swap # mkswap /dev/mapper/Datos-swap2 # mkfs.ext4 /dev/md0 # swapon -p100 /dev/mapper/Datos-swap2 # swapon -p10 /dev/mapper/Datos-swap # mount /dev/mapper/Sistema-root /mnt # mkdir /mnt/var # mkdir /mnt/home # mkdir /mnt/srv # mkdir /mnt/... # mkdir /mnt/boot # mount /dev/mapper/Sistema-var /mnt/var # mount /dev/mapper/Sistema-home /mnt/home # mount /dev/mapper/Datos-srv /mnt/srv # mount /dev/mapper/... /mnt/... # mount /dev/md0 /mnt/boot |
Una vez montadas nuestras unidades en su sitio, instalamos el sistema base de Arch.
1 |
# pacstrap -i /mnt base base-devel |
Realizamos las primeras configuraciones de nuestro nuevo sistema
1 2 |
# mdadm --detail --scan > /mnt/etc/mdadm.conf # genfstab -U /mnt > /mnt/etc/fstab |
Con estos comandos rellenamos un par de archivos, el primero para que nuestro sistema conozca los dispositivos RAID, y el segundo para que conozca como debe montar los volúmenes lógicos y particiones para formar el sistema de ficheros de nuestra instalación.
Ejecutamos el siguiente comando para averiguar el UUID de nuestros dispositivos raid.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
# lsblk -o NAME,FSTYPE,LABEL,UUID,MOUNTPOINT,SIZE NAME FSTYPE LABEL UUID MOUNTPOINT SIZE sda 465,8G ├─sda1 1M ├─sda2 linux_raid_member efc5556d-b95a-33e7-4b8d-849352cf680c 1G │ └─md0 ext4 c290c1e2-4cc9-46c3-85c9-fecd9a8b27c4 /boot 1023M └─sda3 linux_raid_member 30157c6e-4018-970b-84e2-e4018fa7a825 464,7G └─md1 crypto_LUKS 38034031-9f9f-490f-ace2-e8c155f1b5c9 464,6G └─md1_crypt LVM2_member GUhiyc-icef-AYu6-OlEP-VJrn-OEQK-lNBkUV 464,5G ├─sistema-root ext4 f2012104-a878-4ef6-9ef5-c76a1b394daa / 28G ... sdb 465,8G ├─sdb1 1M ... sdc 931,5G └─sdc1 linux_raid_member 12b9151a-1a9d-2d27-c99f-f959d62188d5 931,4G └─md2 crypto_LUKS e854cc1a-bbe4-465f-9e53-a5d1339e5478 931,3G └─md2_crypt LVM2_member 4S7i2l-63FV-NJeV-8Ndw-yPoe-DZ4J-ucvz80 931,3G ├─datos-swap2 swap 6771ec1c-0e61-4826-8352-cdd977c74ce5 [SWAP] 2,8G ... sdd 931,5G └─sdd1 linux_raid_member 12b9151a-1a9d-2d27-c99f-f959d62188d5 931,4G ... |
Obtendremos un resultado similar a este. Apuntamos aparte los UUIDs de md1 y md2.
Hacemos chroot a nuestro nuevo sistema con el comando:
1 |
# arch-chroot /mnt /bin/bash |
Configuramos el nuevo sistema
1 2 3 4 5 6 7 8 9 |
# loadkeys es # nano /etc/locale.gen # locale-gen # export LANG=gl_ES.UTF-8 # echo LANG=gl_ES.UTF-8 >> /etc/locale.conf # nano /etc/vconsole.conf KEYMAP=es FONT=Lat2-Terminus16 FOTN_MAP= |
Esto es prácticamente lo mismo que hicimos anteriormente para configurar el entorno de instalación, pero para nuestro sistema.
1 |
# echo myhostname >> /etc/hostname |
Añadimos el nombre de nuestro equipo
1 |
# ln -s /usr/share/zoneinfo/ContinenteDeCadaUno/Ciudad /etc/localtime |
Escogemos nuestro uso horario
1 |
# hwclock --systohc --utc |
Configuramos el reloj indicando que esta en UTC
1 2 |
# nano /etc/hosts 127.0.0.1 localhost.localdomain localhost myhostname |
Añadimos de nuevo el nombre de nuestro host como alias de la IP 127.0.0.1
1 |
# passwd |
Definimos una clave para el usuario root
1 2 |
# pacman-key --init # pacman-key --populate archlinux |
Inicializamos las llaves de verificación de pacman
1 2 3 4 5 6 7 8 9 |
nano /etc/pacman.conf ILoveCandy [multilib] Include = /etc/pacman.d/mirrorlist [archlinuxfr] SigLevel=Never Server=http://repo.archlinux.fr/$arch |
Añadimos la opción ILoveCandy que le da un mejor aspecto a las barras de progreso de pacman, descomentamos el repositorio multilib si nuestro procesador es, o soporta, arquitectura de 64bits y estamos instalando en esa arquitectura. Y añadimos opcionalmente el repositorio de Arch GNU/Linux Francia para poder disponer de yaourt, que nos permitira instalar comodamente paquetes del repositorio AUR, sin tener que compilarlo desde AUR.
1 2 |
# nano /etc/mkinitcpio.conf HOOKS="base udev autodetect modconf block keyboard encrypt lvm2 filesystems fsck" |
Añadimos en la linea de HOOKS los ganchos de encrypt y lvm2, para disponer de soporte de cifrado y LVM en el kernel, y cambiamos el gancho de keyboard para que se inicie antes del de cifrado, y podamos meter la clave para abrir las unidades al inicio.
1 |
# mkinitcpio -p linux |
Generamos de nuevo las imagenes del kernel con los cambios introducidos.
1 2 3 |
# nano /etc/crypttab md1_crypt UUID=38034031-9f9f-490f-ace2-e8c155f1b5c9 none luks,timeout=180 md2_crypt UUID=e854cc1a-bbe4-465f-9e53-a5d1339e5478 none luks,timeout=180 |
Añadimos una entrada por cada dispositivo cifrado, para que el sistema sepa que nos debe pedir la clave de ese dispositivo al inicio.
Ahora nos toca configurar el gestor de arranque, dado que al tener los dispositivos RAID cifrados, GRUB no sabe donde se encuentra nuestra particion de /.
Ejecutamos a continuación:
1 2 3 |
# nano /etc/default/grub GRUB_CMDLINE_LINUX_DEFAULT="cryptdevice=UUID=38034031-9f9f-490f-ace2-e8c155f1b5c9:md1_crypt root=/dev/mapper/Sistema-root quiet" GRUB_PRELOAD_MODULES="part_gpt part_msdos insmod modraid" |
Buscamos la linea GRUB_CMDLINE_LINUX_DEFAULT y le añadimos los parametros cryptdevice=, indicando el UUID del dispositivo que incluye la particion de /, y root=, indicandole exactamente donde esta esta particon.
Ademas en la linea GRUB_PRELOAD_MODULES le indicamos que carge los mods de insmod y modraid para que GRUB entienda como funcionan los dispositivos RAID.
1 2 3 |
# grub-mkconfig -o /boot/grub/grub.cfg # grub-install --recheck /dev/sda # grub-install --recheck /dev/sdb |
Generamos la configuracion de Grub con los cambios realizados, e instalamos Grub en los dos discos que forman el primer dispositivo RAID. A la hora de generar la configuracion, mientras Grub intenta buscar que sistemas encuentra en los discos, pueden salir multitud de avisos, pero no debemos hacerles caso, a no ser que claramente indique algun error.
Ya solo nos queda reiniciar en nuestro nuevo sistema, y verque todo haya ido bien.
1 2 3 |
# exit # umount /mnt{/boot,/var,/home,...,/} # reboot |
Salimos del chroot de nuevo al entorno de instalacion. Desmontamos las particiones, y reiniciamos.
Si todo fue correctamente despues de escoger la entrada a arrancar en Grub, se nos pedira la clave de cifrado de md1 y a continuacion la de md2, y el sistema arrancara normalmente.
Para acabar ya, diré que no soy ningún experto en el tema. Este tutorial esta hecho a partir de mi propia experiencia, y de lo que he aprendido por ahí. En concreto las fuentes que debería mencionar son tres.
Por un lado la magnifica guía de Arch GNU/Linux, donde se explica las diversas combinaciones jugando con RAID, LUKS y LVM. dm-crypt/Encrypting an entire system.
Por otro lado el par de magnificos post de Archuser, donde explica una manera de hacerlo algo distinta, el crea un sistema LVM con volumenes logicos cifrados dentro. Instalar ArchLinux cifrando el disco con dm-Crypt y LUKS – Parte I y Instalar ArchLinux cifrando el disco con dm-Crypt y LUKS – Parte II – Sistema base.
Y ya finalmente, y dejo de daros la lata, el articulo en ingles de Jayson Ryan: LVM on LUKS on RAID1 on Arch Linux.