Cómo instalar Arch Linux en una memoria USB desde un sistema Linux (Debian)

Vamos a instalar la distributión Arch Linux en una memoria USB desde un sistema preexistente GNU/Linux (Debian).

Este artículo no trata de crear un live USB sino una distribución estandar en una memoria USB.


Realizaremos la instalación de Arch Linux en un proceso de dos pasos. Primero crearemos un lanzador (bootstrap) de Arch Linux en nuestro sistema huesped Debian.
Después ejecutaremos chroot para introducirnos en el lanzador, y entonces instalaremos Arch Linux en la memoria USB.

Instalar Arch Linux desde un sistema Debian preexistente en una memoria USB

Instalar desde un Linux preexistente:
https://wiki.archlinux.org/index.php/Install_from_existing_Linux


Primero enchufamos el dispositivo USB, y comprobamos los dispositivos y particiones con el comando lsblk:
$ lsblk -f
NAME FSTYPE LABEL UUID MOUNTPOINT
sda
├─sda1 ext4 system cbdfff17-0865-448e-b7c1-04a50d168439 /
├─sda2 swap ee7134ec-a542-4c42-8b2e-8e40d3f59980 [SWAP]
└─sda3 ext4 home 9fbcbeb8-8723-43e1-8d08-340af9e14b8b /home
sdb
└─sdb1
sr0

Vamos a instalar Arch Linux en el dispositivo /dev/sdb (usa el adecuado para tu sistema)

Particionamos el dispositivo y creamos una partición arrancable.
$ sudo fdisk -l /dev/sdb
Disk /dev/sdb: 15 GiB, 16131293184 bytes, 31506432 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0x04030201

Device Boot Start End Sectors Size Id Type
/dev/sdb1 * 2048 31506431 31504384 15G 83 Linux


Formateamos la partición con el sistema de ficheros ext4 sin journaling para minimizar el número escrituras a la memoria USB.
$ sudo mkfs.ext4 -O "^has_journal" -L 'ArchUSB' /dev/sdb1

Descargamos el lanzador de Arch Linux

La arquitectura de mi sistema es x86_64.
$ uname -m
x86_64

Obtenemos la imagen ISO del lanzador de un mirror listado en la siguiente página:
https://www.archlinux.org/download/

Descargamos el lanzador:
$ curl -O http://sunsite.rediris.es/mirror/archlinux/iso/2016.11.01/archlinux-bootstrap-2016.11.01-x86_64.tar.gz

Bajamos la firma al mismo directorio:
$ curl -O http://sunsite.rediris.es/mirror/archlinux/iso/2016.11.01/archlinux-bootstrap-2016.11.01-x86_64.tar.gz.sig

Y verificamos que la firma coincide con la imagen ISO:
$ gpg --keyserver-options auto-key-retrieve --verify archlinux-bootstrap-2016.11.01-x86_64.tar.gz.sig


Creamos el directorio en el sistema huesped para extraer el lanzador:
$ mkdir arch_chroot

Extraemos el archivo tar.gz:
$ tar xzf archlinux-bootstrap-2016.11.01-x86_64.tar.gz -C arch_chroot


Editamos arch_chroot/root.x86_64/etc/pacman.d/mirrorlist y descomentamos el mirror que vamos a usar:
(Descomentar varios mirrors es una buena idea)
P.ej:

Server = http://sunsite.rediris.es/mirror/archlinux/$repo/os/$arch

Vamos a entrar en la jaula chroot:
https://wiki.archlinux.org/index.php/Change_root

$ sudo mount --bind arch_chroot/root.x86_64 arch_chroot/root.x86_64 # Esto proporciona / en el entorno chroot.
$ cd arch_chroot/root.x86_64/
$ sudo cp /etc/resolv.conf etc
$ sudo mount -t proc /proc proc
$ sudo mount --rbind /sys sys
$ sudo mount --rbind /dev dev
$ sudo mount --rbind /run run # (asumiendo que /run existe en el sistema)
$ sudo chroot . /bin/bash
[root@ /]#
Ahora estamos dentro de la jaula chroot.

Instalamos los paquetes que necesitamos en el lanzador de Arch Linux

Primero vamos a inicializar el administrador de paquetes pacman:

https://wiki.archlinux.org/index.php/Pacman

Inicializamos el anillo de claves de pacman:
https://wiki.archlinux.org/index.php/Pacman-key#Initializing_the_keyring

# pacman-key --init
El sistema necesitará entropía así que abrimos otra consola (en la máquina huesped) y ejecutamos $ ls -Ra / varias veces.

# pacman-key --populate archlinux


https://wiki.archlinux.org/index.php/Mirrors#Enabling_a_specific_mirror
sincronizamos las bases de datos de paquetes: (si un servidor no funciona editamos más en etc/pacman.mirrorlist)
# pacman -Syyu
:: Synchronizing package databases...


Instalamos los paquetes básicos:
# pacman -S base

Instalamos los paquetes básicos de Arch Linux en la memoria USB

Guía general de instalación:
https://wiki.archlinux.org/index.php/Installation_guide


Montamos el dispositivo USB en el directorio /mnt:
# mount /dev/sdb1 /mnt

Instalamos los paquetes base:
# pacstrap /mnt base

Generamos el fichero fstab (Yo uso -U para usar el UUID en las definiciones):
# genfstab -U /mnt /mnt/etc/fstab
Comprobamos que /mnt/etc/fstab contiene los datos correctos.

Cambiar a usuario root en el nuevo sistema:
# arch-chroot /mnt

Configuramos la zona horaria: (utiliza tu Región y Ciudad /usr/share/zoneinfo/Región/Ciudad )
# ln -s /usr/share/zoneinfo/Europe/Madrid /etc/localtime

Ejecutamos hwclock(8) para generar /etc/adjtime:
# hwclock --systohc

Locale

Descomentamos en_US.UTF-8 UTF-8 y las localizaciones que necesitemos en /etc/locale.gen, y la generamos mediante:
# locale-gen

Configuramos la variable LANG en locale.conf(5) adecuadamente, por ejemplo:

/etc/locale.conf

LANG=en_US.UTF-8

No existía así que la creamos:
# echo "LANG=en_US.UTF-8" /etc/locale.conf

Teclado

Si configuras el mapa del teclado, recuerda hacer los cambios persistentes en vconsole.conf(5):

/etc/vconsole.conf

P.ej: KEYMAP=de-latin1

Para listar los mapas de teclado disponibles:
# ls /usr/share/kbd/keymaps/**/*.map.gz

Elijo 'es' para el mapa de teclado en español:
# echo "KEYMAP=es" /etc/vconsole.conf

Hostname

Creamos el fichero hostname(5):

/etc/hostname

P.ej: A mi sistema lo llamo archUSB:
# echo "archUSB" > /etc/hostname


Considerar el añadir una entrada que concuerde al fichero hosts(5):

/etc/hosts

127.0.0.1 localhost.localdomain localhost
::1  localhost.localdomain localhost
127.0.1.1 archUSB.localdomain archUSB

Password de Root

Configuramos el password del usuario root:
# passwd

Configuración de red (dentro de la jaula chroot)

Configuramos la red para en entorno recien instalado
https://wiki.archlinux.org/index.php/Network_configuration

Para la configuración 'Wireless', instalamos iw, wpa_supplicant, el paquete dialog, y los paquetes que sean necesarios de firmware.

Instalamos en administrador de red:
# pacman -S networkmanager

y dhclient:
# pacman -S dhclient

Initramfs

En este caso vamos a necesitar crear un nuevo initramfs.


Modificamos el fichero mkinitcpio.conf(5):

Editamos y decomentamos ésto en /etc/mkinitcpio.conf para que aparezca la palabra block:

HOOKS="base udev block filesystems"

Para evitar el error crc32c al cargar los módulos:

MODULES="crc32 libcrc32c crc32c_generic crc32c-intel crc32-pclmul"

Recreamos la imagen initramfs:
# mkinitcpio -p linux

BOOTLOADER

Bootloader (Selecciono GRUB porque mi sistema no soporta UEFY):
https://wiki.archlinux.org/index.php/GRUB#BIOS_systems

Instalo grub en lugar de grub-legacy:
# pacman -S grub

# grub-install --target=i386-pc /dev/sdb
ó
# grub-install --target=i386-pc --recheck /dev/sdb
Installing for i386-pc platform.
Installation finished. No error reported.

# grub-mkconfig -o /boot/grub/grub.cfg
Generating grub configuration file ...
Found linux image: /boot/vmlinuz-linux
Found initrd image(s) in /boot: initramfs-linux.img
Found fallback initrd image(s) in /boot: initramfs-linux-fallback.img
done


Salimos del último entorno chroot usando el comando exit:
# exit

Ahora desmontamos manualmente todas las particiones (si alguna esta ocupada usamos fuser para buscar la causa)
# umount -R /mnt

Salimos del segundo chroot
# exit

Ahora volvemos a estar en el sistema huesped:
$ cd ..
$ sudo umount -R root.x86_64


Ahora ya podemos arrancar nuestro nuevo sistema Arch Linux en la memoria USB, o testearlo en un emulador.

Para testear la memoria USB con Arch Linux en virtualbox:
VirtualBox: add a physical hard disk to your virtual machine in Debian

Configuración de la red (en el sistema en marcha Arch Linux de la memoria USB)

https://wiki.archlinux.org/index.php/Network_configuration

Vamos a configurar una dirección dinámica en una interfaz de red cableada.
Hay que elegir un método de configuración de la red porque varios métodos a la vez pueden causar conflictos.

Comprobamos el estado actual de las interfaces de red

P.ej: Mostramos todos los dispositivos de red:
$ ip link show
1: lo: mtu 65536 qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
2: eth0: mtu 1500 qdisc mq state UP mode DEFAULT group default qlen 1000
link/ether 70:5a:b6:43:58:8c brd ff:ff:ff:ff:ff:ff


P.ej: Mostramos las direcciones:
$ ip address
1: lo: mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
2: eth0: mtu 1500 qdisc mq state UP group default qlen 1000
link/ether 70:5a:b6:43:58:8c brd ff:ff:ff:ff:ff:ff
inet 192.168.0.105/24 brd 192.168.0.255 scope global eth0
valid_lft forever preferred_lft forever
inet6 fe80::725a:b6ff:fe43:588c/64 scope link
valid_lft forever preferred_lft forever

Configuramos la red usando dhclient

Para que ésto funcione necesitamos que hayamos instalado dhclient durante el proceso de bootstrap:
# packman -S dhclient

Activamos el dispositivo de red:
# ip link set enp0s3 up

Pedimos una dirección dinámica:
# dhclient enp0s3

Comprobamos que funciona:
# ip address show enp0s3

# ping www.google.com

Cómo configurar un perfil de netctl y ponerlo en marcha

Configuramos la red usando un perfil (P.ej: el perfil dhcp)

https://wiki.archlinux.org/index.php/Netctl

Copiamos el perfil de ejemplo:
# cp /etc/netctl/examples/ethernet-dhcp /etc/netctl/my-ethernet-dhcp-profile

Lo editamos para que coincida con el nombre de nuestra interfaz de red:
# nano /etc/netctl/my-ethernet-dhcp-profile
cambiamos Interface=eth0 a Interface=enp0s3

Hay que asegurarse que el dispositivo esta desactivado cuando ponemos en marcha el perfil:
# ip link set enp0s3 down

Lanzamos el perfil:
# netctl start my-ethernet-dhcp-profile

Comprobamos que funciona:
# ping www.google.com

La siguiente vez que arranquemos el sistema el perfil se ejecutará automáticamente.

Cómo configurar el servidor SSH

Si queremos conectarnos remotamente al sistema Arch Linux podemos usar un servidor sshd.

https://wiki.archlinux.org/index.php/Secure_Shell

Instalamos el servidor de ssh:
# pacman openssh

Editamos el fichero de cofniguración para el servidor de ssh:
# nano /etc/ssh/ssdh_config

Si queremos loguearnos como root (aunque es inseguro):
PermitRootLogin yes

Lanzamos el servidor
# systemctl edit sshd.socket

https://wiki.archlinux.org/index.php/Start
# systemctl start sshd.socket

Si falla, para mirar los logs:
# journalctl /usr/bin/sshd


En la máquina remota ejecutamos:
$ ssh -l root address_of_your_arch_linux_machine

TRADUCIDO DE

How to install Arch Linux on a USB key from an existing Linux (Debian)

REFERENCIA

Arch Linux distro - Introduction

Improving_performance (Arch Linux wiki)