Introducción

Es importante leer la introducción atentamente.

Arch es una distribución difícil que no está pensada para iniciarse. Si no se tiene cierta soltura con Linux puede ser una experiencia abrumadora.

Tampoco el tutorial está pensado para explicar todas las posibilidades. Simplemente recoge una experiencia que puede ser útil para aquellos en la misma situación.

Arch Linux como sistema único en el PC. Es decir sin Windows.
Disco de estado sólido (SSD).
UEFI (Gummiboot como gestor de boot UEFI).

Por experiencia. Cada vez que he tenido que volver a instalar Arch mis apuntes se han quedado obsoletos. Así que lo que recomiendo es si han pasado ya algunos meses ir comparando con la página de instalación de la web de Arch Linux.

Resumiendo lo que vamos a ver. En esta primera parte instalaremos el sistema Linux sin la parte gráfica. En la segunda parte añadiremos el sistema gráfico con Openbox como gestor de ventanas, Tint2 como barra de tareas y PCmanFM como gestor de ficheros.

Ante cualquier duda lo mejor es ir a las páginas de Arch Linux. La mayoría tiene su versión en español.

Versiones

23 Mayo 2015. Primera versión.
8 Abril 2016. Segunda versión.
- Actualizaciones del microcode Intel salen del kernel para ser aplicadas en el proceso de boot.
- Gummiboot ha pasado a llamarse systemd-boot.

8 Abr
2016

INSTALACIÓN ARCH LINUX (1)

Autor: Alberto Peiró

Labels: Linux

Instalación Arch Linux (1)

Parte I. Sistema básico

Preparación
Pre-particionado para UEFI
Arranque desde el instalador
Conexión a internet
Particionado
Montaje
Instalación del sistema base
Configuración del sistema

Preparación

Obtenemos la imagen de https://www.archlinux.org/download/.

Una vez descargada comprobamos la integridad del archivo comparando su "hash" o con la firma.

pacman-key -v arch_distro.sig

El siguiente paso es grabar el instalador en el medio con el que iniciaremos el sistema.

Caso de una memoria USB o SD.
```
dd if=ruta_a_la_imagen of=ruta_al_soporte bs=4K
dd if=ruta_al_soporte count=num_de_bloques status=noxfer | sha256sum
```
La última instrucción es para comprobar que la imagen se ha grabado adecuadamente. El número de bloques lo tomaríamos de la salida al hacer la copia, y la opción noxfer hace que no se envíen las estadísticas dadas por el comando dd.

Cuidado

Mucho cuidado con el comando dd. Algunos piensan que el nombre viene de "data destructor". Si nos equivocamos de dispositivo puede que borremos el disco duro.
Caso de un cd/dvd.

Cualquier software de grabación de CDs o DVDs, o en el caso de que lo queramos hacer desde la línea de comandos, podemos usar las utilidades que se encuentran en el paquete cdrtools.
```
wodim -checkdrive
wodim -v dev=/dev/sr0 -blank=all
wodim -v dev=/dev/sr0 ruta_a_la_imagen
dd if=/dev/sr0 status=noxfer | sha256sum
```
Descubriríamos el dispositivo a utilizar con la primera instrucción. En este caso sr0. Y la última nos sirve para comprobar que la grabación ha sido correcta.

Pre-particionado UEFI

Nota

Antes de arrancar el instalador podemos crear las particiones donde instalaremos el nuevo sistema. Por ejemplo desde una distribución live con gparted o instalando una distribución como Fedora en un USB.

Ver el apartado de particionado.

Arranque desde el instalador

Arrancamos el ordenador usando la imagen que acabamos de grabar. Aparecerá el siguiente prompt indicando que hemos ingresado al sistema como root.

root@archiso ~ #

Nota

En una placa base con UEFI automáticamente se lanzará Gummiboot que presentará un menú con varias opciones.

Arch Linux archiso x86_64 UEFI USB
UEFI Shell x86_64 v1
UEFI Shell x86_64 v2
EFI Default Loader

Elegiremos la primera. Y una vez en la shell verificamos que realmente hemos arrancado en modo UEFI.

# efivar -l

Como salida debería aparecer un listado de variables UEFI.

para trabajar con más comodidad cargamos el mapa de teclado español.

# loadkeys es

Conexión a internet

Nos centramos solo en la conexión wifi. Usaremos wifi-menu que generará un fichero de configuración para netctl.

Identificamos el nombre de la interfaz wifi.

# iw dev
phy#0
        Interface wlp3s0
                ifindex 3
                wdev 0x1
                addr 00:11:22:33:44:55
                type managed

Y a continuación lanzamos wifi-menu con el nombre que nos ha dado: wlp3s0

# wifi-menu wlp3s0

Particionado

Lo más sencillo es haber creado anteriormente las particiones desde un programa como gparted. Sin embargo se puede hacer desde línea de comandos con parted.

Particionado para instalación UEFI.

Usando gparted crear una tabla de particiones GPT y una partición en FAT-32 para el sistema EFI. Esta última debe estar marcada como boot (en gparted como efi y boot). Pensando en Linux EFI boot stub el tamaño debería ser mayor que el que recomiendan para los bootloader, 512MiB, ya que es un ejecutable EFI que incorpora la imagen del kernel y la initramfs.

Montaje

Empezamos montando la partición raíz del nuevo sistema en /mount. La información del dispositivo se puede obtener con lsblk o dmesg.

# mount /dev/sda2 /mnt

Con base en este punto de montaje se montan el resto de particiones.

Por ejemplo, si tenemos una partición distinta para el directorio /home.

# mkdir /mnt/home
# mount /dev/sda3 /mnt/home

Para la partición EFI. Pensando en lanzar la imagen del kernel de Linux con EFISTUB directamente, sin usar un bootloader, se recomienda montarla en /boot.

# mkdir /mnt/boot
# mount /dev/sda1 /mnt/boot

Instalación del sistema base

El script pacstrap se encargará de instalar los paquetes esenciales del nuevo sistema operativo.

# pacstrap /mnt base base-devel

Otros paquetes que quizá debamos instalar en este momento son iw y wpa_supplicant. Sobre todo si el nuevo sistema se conecta a una wifi con WPA. De paso instalamos también el editor vim (u otro editor como nano)..

# pacstrap /mnt iw wpa_supplicant vim

Configuración del sistema base

Generamos automáticamente la tabla del sistema de ficheros (fstab). La opción -U es para usar UUIDs en la tabla.

# genfstab -U -p /mnt >> /mnt/etc/fstab

Es buena idea chequear la tabla y añadir opciones como discard para activar TRIM en el caso de un SSD.

El siguiente sería un ejemplo de fstab para un SSD con una partición EFI. En el autogenerado puede que aparezcan más opciones pero será más o mentos parecido al siguiente. Por claridad he cambiado la UUID por el dispositivo.

# 
# /etc/fstab: static file system information
#
#<file system> <dir> <type> <options>     <dump> <pass>
/dev/sda2    /       ext4   rw,relatime,discard 0 1
/dev/sda1    /boot   vfat   rw,relatime,fmask=0022,dmask=0022,discard 0 2
/dev/sda3    /home   ext4   rw,relatime,discard 0 2

Nota

TRIM es un comando que comunica los bloques marcados por el sistema como no en uso al SSD para que este se encargue del borrado reduciendo el número de escrituras en disco.

Para verificar si el SSD soporta TRIM con la siguiente instrucción:

# hdparm -I /dev/sdX | grep TRIM

En caso afirmativo añadimos la opción discard al la tabla del sistema de ficheros (fstab).

I/O scheduler. Es el encargado de reordenar las peticiones de acceso al disco. Normalmente por defecto se usa CFQ que intenta agrupar las peticiones que físicamente se encuentran cercanas en un HDD. Otras opciones pensadas para SDD son NOOP y deadline.

Más adelante, cuando arranquemos ya con el sistema final comprobamos cual es scheduler activo (el que se encuentre entre corchetes) y que opciones existen:

$ cat /sys/block/sdX/queue/scheduler
noop deadline [cfq]

Cambiamos el I/O scheduler a NOOP.

# echo noop > /sys/block/sdX/queue/scheduler

Otras opciones de montaje en fstab para disminuir el número de escrituras en un SSD.

noatime: cuando un fichero es abierto sin ser modificado no actualiza los tiempos de acceso (al inode) con lo que se evitan escrituras en el disco.
relatime: similar al anterior pero se asegura que el tiempo de acceso no es anterior a la última modificación.

Cuidado

Hay que estar seguro que el SSD soporta TRIM antes de utilizar la opción discard. Si no podría provocar pérdida de datos.

Ahora cambiamos el directorio que aparecerá como raíz para los procesos en marcha y sus descendientes al nuevo que acabamos de montar en /mnt.

Aprovechamos el script arch-chroot que monta ficheros como /proc /sys y /dev, también hace que /etc/resolv.conf esté disponible para tener acceso a internet desde el nuevo entorno.

# arch-chroot /mnt /bin/bash

Nota

El script es equivalente a realizar los siguientes pasos:

Montar los ficheros virtuales

# cd /mnt/
# mount -t proc proc proc/
# mount --rbind /sys sys/
# mount --rbind /dev dev/
# mount --rbind /run run/

Mantener la conexión a internet.

# cp /etc/resolv.conf etc/resolv.conf

Realizar el cambio de directorio raíz en la que usaremos bash.

chroot /mnt/ /bin/bash

Ficheros de configuración a crear o editar:

Configuración local

Aquí se define el idioma que usa sistema y otras características regionales. En /etc/locale.gen están todas las opciones. Seleccionamos las siguientes:
```
#...
#en_SG ISO-8859-1
en_US.UTF-8 UTF-8
#en_US ISO-8859-1
#...
#es_EC ISO-8859-1
es_ES.UTF-8 UTF-8
#es_ES ISO-8859-1
#...
```
Luego hay que generar los "locales".
```
# locale-gen
```
Indicarle que local es el activo.
```
# echo LANG=es_ES.UTF-8 > /etc/locale.conf
```
Y exportar la variable de entorno.
```
# export LANG=es_ES.UTF-8
```
Mapa del teclado de la terminal (distinto al del sistema de ventanas)
```
# echo KEYMAP=es > /etc/vconsole.conf
```
Zona horaria

Para especificar la zona horaria haremos un enlace simbólico del localtime con la zona horaria.
```
# ln -s /usr/share/zoneinfo/Europe/Madrid /etc/localtime
```
Configuración del reloj

Utilizaremos UTC.
```
# hwclock --systohc --utc
```

Nombre del equipo

Lo importante es que coincida el valor en /etc/hostname y en /etc/hosts.

# echo my_hostname > /etc/hostname

Archivo /etc/hosts:

#ip-address  hostname.domain.org    hostname
127.0.0.1    localhost.localdomain  localhost  my_hostname
::1          localhost.localdomain  localhost  my_hostname

Conexión de red

Antes hemos usado netctl-menu para configurar la red del instalador. Ahora hay que configurar la conexión para el nuevo sistema. Se puede dejar para más adelante pero ahora tenemos disponible pacman para descargar cualquier paquete que nos haga falta.

El caso que tratamos es el de conectarnos a una wifi con WPA usando netctl. Si no lo hemos hecho antes (con pacstrap) instalamos iw y wpa_supplicant.
```
# pacman -S iw wpa_supplicant
```
Copiamos la siguiente configuración de ejemplo en /etc/netctl.
```
# cp /etc/netctl/examples/wireless-wpa /etc/netctl/homewifi
```
Modificamos la Interface (la que nos a salida antes con iw dev), la ESSID (nombre de la red) y la Key (clave).

Finalmente, habilitamos el servicio para que se inicie al arrancar el sistema.
```
# systemctl enable homewifi
```
Nota

Si alguien le preocupa la seguridad puede cambiar los permisos de lectura del archivo donde está la clave.
Creación del ramdisk

No hace falta correr mkinitcpio -p linux porque pacstrap ya se ha encargado de hacerlo.
Contraseña para el usuarip root

Lanzar el comando passwd que pedirá que se teclee dos veces la contraseña.
```
# passwd
```

Bootloader

Caso de UEFI.

Usaremos systemd-boot (anteriormente GummiBoot) que es un gestor de arranque, no un bootloader, que sólo es capaz de iniciar ejecutables como un kernel con efistub, una shell efi, Windows Boot Manager o GRUB.

Previamente hay que instalar el paquete dosfstools para manipular la partción ESP (FAT-32) y efibootmgr para crear la entrada de systemd-boot (anteriormente Gummiboot) en el gestor de arranque EFI.

# pacman -S dosfstools efibootmgr

!Nota

El disco tiene que estar particionado como GPT y tener una partición para el sistema EFI (ESP).
Partición EFI montada en /boot (necesario para actualizar automáticamente Gummiboot). Ahora, con systemd-boot, esta actualización no es automática y hay que lanzar el comando bootctl update cuando esté disponible una nueva versión (bootctl status).

Ahora ya no hay que instalar un paquete como el paquete gummiboot. Systemd-boot viene con systemd. Para instalar el gestor de arranque ejecutamos el script automático con systemctl install. Donde $esp es el punto de montaje de la partición del sistema EFI que por defecto toma el valor de /boot.

# bootctl --path=$esp install

Systemd-boot será detectado automáticamente por el firmware EFI que no tiene determinado un bootloader y que busca en su defecto uno en $esp/efi/boot/bootx64.efi. Sin embargo aún hay que configurar systemd-boot.

Para añadir entradas de arranque hay que crear un archivo individual en $esp/loader/entries/arch.conf con las rutas al kernel efistub relativas a $esp (en este caso /boot). La opción root apunta a la partición en la que se encuentra el sistema de archivos raíz.

/boot/loader/entries/arch.conf

title      Arch Linux
  linux    /vmlinuz-linux
  initrd   /initramfs-linux.img
  options  root=/dev/sda2 rw

!Nota

Es mejor utilizar la id de la partición que se puede conseguir con lsblk -o NAME,PARTUUID (o blkid -s PARTUUID -o value /dev/sda2). Si no aparece nada lo podemos modificar después ya con el sistema final funcionando.

  options  root=/PARTUUID=6eb99c1b-b0c8-4012-bed1-489982559437 rw

El segundo archivo es necesario para la configuración general de gummiboot en $esp/loader/loader.conf

default arch
timeout 5

Caso BIOS.

La opción más común es GRUB. Lo instalamos en un disco (no en una partición) y creamos el archivo de configuración.

pacman -S grub
grub-install --recheck /dev/sdX
grub-mkconfig -o /boot/grub/grub.cfg

Intel microcode

Para activar las actualizaciones del microcode del micropocesador (Intel) hay que efectuar dos pasos.

1) Istalar el paquete intel-ucode

2) Hacer que el bootloader cargue el microcode

install -S intel-ucode

El microcode debe ser cargado por el bootloader.

/boot/loader/entries/arch.conf

title      Arch Linux
  linux    /vmlinuz-linux
  initrd   /intel-ucode.img
  initrd   /initramfs-linux.img
  options  root=/dev/sda2 rw

Desmontar las particiones y reiniciar

Salimos del entorno chroot.

# exit

Apagamos el equipo. Systemd se encargará de desmontar automáticamente las particiones.

# reboot

Otra orden para apagar el sistema es shutdown.

# shutdown -h now