Difference between revisions of "Install from existing Linux (Español)"

From ArchWiki
Jump to: navigation, search
(Método 2: Utilizar la imagen del LiveCD)
(15 intermediate revisions by 5 users not shown)
Line 1: Line 1:
[[Category:Obteniendo e instalando Arch (Español)]]
+
[[Category:Getting and installing Arch (Español)]]
[[Category:CÓMOs (Español)]]
+
[[de:Schnellinstallation von einem bestehenden Linuxsystem]]
{{i18n| Guía rápida de instalación de Arch Linux}}
+
[[en:Install from Existing Linux]]
{{translateme}}
+
[[fr:Install chroot]]
 +
[[it:Install from Existing Linux]]
 +
[[pt:Install from Existing Linux]]
 +
[[ru:Install from Existing Linux]]
 +
[[uk:Install from Existing Linux]]
 +
[[zh-CN:Install from Existing Linux]]
 +
[[zh-TW:Install from Existing Linux]]
  
Esta guía ha sido suplantado por: [[Install From Existing Linux]]
+
Este documento describe el proceso de [[wikipedia:es:Bootstrapping_(informática)|bootstrapping]] necesario para instalar Arch Linux desde un sistema anfitrión de Linux en ejecución. Después del bootstrapping, la instalación continúa como se describe en la [[Installation Guide (Español)|guía de instalación]].
  
Más en [http://bbs.archlinux.org/viewtopic.php?id=51315 este hilo].
+
La instalación de Arch Linux desde un sistema Linux en ejecución es útil para:
 +
* instalar remótamente Arch Linux, por ejemplo, un servidor root (virtual)
 +
* sustituir un Linux existente sin un LiveCD (véase [[#Sustituir el sistema existente sin un LiveCD]])
 +
* crear un distribución Linux nueva o LiveCD basada en Arch Linux
 +
* crear un entorno chroot de Arch Linux, por ejemplo para un contenedor de base Docker
 +
* [[Diskless_network_boot_NFS_root|rootfs-sobre-NFS para máquinas sin disco]]
  
{{i18n_links_start}}
+
El objetivo del procedimiento de bootstrapping es configurar un entorno desde el que ejecutar los {{Pkg|arch-install-scripts}} (tales como {{ic|pacstrap}} y {{ic|arch-root}}).
{{i18n_entry|Deutsch|Schnellinstallation von einem bestehenden Linuxsystem (Deutsch)}}
+
Este objetivo se logra mediante la instalación de los {{Pkg|arch-install-scripts}} nativos en un sistema anfitrión, o configurando un entorno chroot basado en Arch Linux.
{{i18n_entry|English|Fast Arch Install from existing Linux System}}
+
{{i18n_entry|Español|Instalación rápida de Arch Linux con un sistema existente}}
+
{{i18n_entry|繁體中文|F.在安裝了 Linux 的電腦上快速安裝 Arch}}
+
{{i18n_entry|简体中文|在安装了 Linux 的电脑上快速安装 Arch}}
+
{{i18n_links_end}}
+
  
Si está ejecutando Linux y ya no tiene un grabador de CD o simplemente quiere un rápido proceso de instalación, aquí se explica cómo instalar desde el disco duro.
+
Si el sistema anfitrión ejecuta Arch Linux, la instalación de los {{Pkg|arch-install-scripts}} es sencilla.
  
Lea la [[Official Arch Linux Install Guide]] primero para que sepa qué esperar.
+
Desde otras distribuciones, el proceso es más complicado (el cual se describe en [[#Alternativa: Instalación de los arch-install-scripts nativos en una distribución que no sea Arch]]).
 +
Para estas distribuciones, se recomienda la creación de un entorno chroot en su lugar.
  
Usted necesita una partición de repuesto '''más''' grande que la iso de Arch. Here Aquí estoy conectado como '''root''' y estoy usando "/dev/hda12" que pasa a ser de 6GB.
+
{{Nota|Esta guía requiere que el sistema anfitrión existente sea capaz de ejecutar los nuevos programas de Arch Linux para la arquitectura de destino. En el caso de un anfitrión x86_64, es posible utilizar i686-Pacman para construir un entorno chroot de 32 bits. Véase [[Arch64 Install bundled 32bit system]]. Sin embargo, no es tan fácil construir un entorno de 64 bits cuando el anfitrión solo permite ejecutar programas de 32 bits.}}
  
Dependiendo de su gestor de arranque, siga la sección "LILO" o "GRUB". Entonces "REINICIAR E INSTALAR" sección
+
==Efectuar chroot basado en Arch Linux==
  
==Lilo==
+
La idea es ejecutar un sistema Arch en el sistema anfitrión.
 +
La instalación en curso se ejecuta desde este sistema Arch.
 +
Este sistema anidado está contenido dentro de un entorno chroot.
 +
Existen tres métodos para configurar e introducirnos en un entorno chroot, que se presentan a continuación, desde el más sencillo hasta el más complejo.
  
1) Copiar la iso a la partición de respuesto (usted puede utilizar una copia recursiva de fricción, cp -R en lugar de dd; dd a veces enrosca la partición):
+
{{Nota|Su sistema anfitrión debe ejecutar Linux 2.6.32 o superior}}
dd if=arch-0.7.iso of=/dev/hda12
+
  
2) Montar la partición en algún lugar. Use un adecuado punto de montaje (se puede utilizar la opción de montaje -tiso9660 pero deben trabajar hacia fuera):
+
===Método 1: Utilizar la imagen Bootstrap===
mkdir /mnt/archCD
+
mount /dev/hda12 /mnt/archCD
+
  
3) Edite lilo.conf y añadir:
+
Descargue la imagen Bootstrap desde un [https://www.archlinux.org/download servidor de réplica]:
image=/mnt/archCD/isolinux/vmlinuz
+
  curl -O http://www.gtlib.gatech.edu/pub/archlinux/iso/2013.10.01/archlinux-bootstrap-2013.10.01-x86_64.tar.gz
        label=archCD
+
Extraiga el archivo tar:
        initrd=/mnt/archCD/isolinux/initrd.img
+
  # cd /tmp
        append="root=/dev/hda12 BOOTMEDIA=cd"
+
  # tar xzf <path-to-bootstrap-image>/archlinux-bootstrap-2013.10.01-x86_64.tar.gz
 +
Seleccione un servidor de repositorio:
 +
  # nano /tmp/root.x86_64/etc/pacman.d/mirrorlist
 +
Entre en el entorno chroot:
 +
* Si tiene bash 4 o superior instalado:
 +
  # /tmp/root.x86_64/bin/arch-chroot /tmp/root.x86_64/
 +
* Después ejecute las órdenes suiguientes:
 +
  # cp /etc/resolv.conf /tmp/root.x86_64/etc
 +
  # mount --rbind /proc /tmp/root.x86_64/proc
 +
  # mount --rbind /sys /tmp/root.x86_64/sys
 +
  # mount --rbind /dev /tmp/root.x86_64/dev
 +
  # mount --rbind /run /tmp/root.x86_64/run
 +
    (presumiento que /run exista en su sistema)
 +
  # chroot /tmp/root.x86_64/
  
no se olvide ejecutar:
+
===Método 2: Utilizar la imagen del LiveCD===
lilo
+
  
==Grub==
+
Es posible montar la imagen root con el soporte de instalación de Arch Linux más reciente y luego efectuar chroot en él. Este método tiene la ventaja de que proporciona una instalación de Arch Linux funcionando bien dentro de su sistema anfitrión, sin necesidad de prepararlo mediante la instalación de paquetes específicos.
  
Yo no he sido capaz de arrancar una partición del disco duro que contiene la iso Arch con grub, la ISO primero debe ser descomprimida en una partición ordinaria. Esto es todavía más rápido que la grabación de un CD:
+
{{Nota|Antes de continuar, asegúrese de que la última versión de [http://squashfs.sourceforge.net/ squashfs] está instalada en el sistema anfitrión. De lo contrario, se producirán errores como: {{ic|FATAL ERROR aborting: uncompress_inode_table: failed to read block}}.}}
  
1) EL formato de la partición de repuesto y de montaje es el siguiente:
+
* La imagen root se puede encontrar en uno de los [https://www.archlinux.org/download servidores de réplica], disponible tanto para arquitecturas x86_64 como i686, dependiendo de sus necesidades.El formato squashfs no es editable, así que efectuaremos ''unsquash'' de la imagen root y luego la monteremos.
  
mkreiserfs /dev/hda12
+
*Para efectuar unsquash de la imagen root, ejecute:
mkdir /mnt/archCD
+
{{bc|# unsquashfs -d /squashfs-root root-image.fs.sfs}}
mount /dev/hda12 /mnt/archCD
+
  
2) Monte la ISO Arch (use un adecuado punto de montaje):
+
* Ahora se puede montar la imagen root con la opción loop:
mkdir /mnt/tmp
+
{{bc|
mount -o loop arch-0.7.iso /mnt/tmp
+
# mkdir /arch
 +
# mount -o loop /squashfs-root/root-image.fs /arch
 +
}}
  
3) Copiar la ISO a la partición de repuesto:
+
* Antes de [[Change Root|enjaularlo]], tenemos que establecer algunos puntos de montaje y copiar el archivo resolv.conf para las conexiones de red:
cd /mnt/tmp
+
{{bc|
cp -a * /mnt/archCD
+
# mount -t proc none /arch/proc
 +
# mount -t sysfs none /arch/sys
 +
# mount -o bind /dev /arch/dev
 +
# mount -o bind /dev/pts /arch/dev/pts # important for pacman (for signature check)
 +
# cp -L /etc/resolv.conf /arch/etc #this is needed to use networking within the chroot
 +
}}
  
4) modifique <code>/boot/grub/menu.lst</code>
+
* Ahora está todo preparado para enjaular (efectuar chroot) el entorno donde Arch se va a instalar:
title ArchCD
+
{{bc|# chroot /arch bash}}
kernel (hd0,11)/isolinux/vmlinuz root=/dev/hda12 BOOTMEDIA=cd
+
initrd (hd0,11)/isolinux/initrd.img
+
  
== Reinicie e instalar Arch ==
+
===Método 3: Montar manulamente el entorno chroot (con un script)===
  
Reinicie y seleccione '''archCD''', cuando el instalador le pregunta si está utilizando un CD o SRC, puede salir de un salto a otro shell si está utilizando lilo:
+
El script crea un directorio llamado {{ic|archinstall-pkg}} y descarga los paquetes necesarios en él. A continuación, los extrae al directorio {{ic|archinstall-chroot}}. Por último, prepara los puntos de montaje, configura pacman y enjaula el entorno.
mount -t iso9660 /dev/hda12 /src
+
if you are using grub:
+
mount /dev/hda12 /src
+
  
* Sustituir <code> / dev/hda12 </ code> con la partición de repuesto a asignar
+
{{hc|archinstall-bootstrap.sh|<nowiki>
* Recuerde que puede utilizar "la implementación del tabulador" para encontrar esa partición, en vez de escribir todo
+
#!/bin/bash
* Luego saltar hacia atrás, a la instalación desde un disco duro seleccionando SRC en lugar de CD.
+
# This script is inspired on the archbootstrap script.
  
== Y para recuperar la partición de repuesto cuando Arch está en marcha y funcionando ...==
+
PACKAGES=(acl attr bzip2 curl expat glibc gpgme gnupg libarchive libassuan libgcrypt libgpg-error libssh2 lzo2 openssl pacman xz zlib pacman-mirrorlist coreutils bash grep gawk file filesystem tar ncurses readline libcap util-linux pcre arch-install-scripts)
 +
# Change the mirror as necessary
 +
MIRROR='http://mirrors.kernel.org/archlinux'
 +
# You can set the ARCH variable to i686 or x86_64
 +
ARCH=`uname -m`
 +
LIST=`mktemp`
 +
CHROOT_DIR=archinstall-chroot
 +
DIR=archinstall-pkg
 +
mkdir -p "$DIR"
 +
mkdir -p "$CHROOT_DIR"
 +
# Create a list with urls for the arch packages
 +
for REPO in core community extra; do 
 +
        wget -q -O- "$MIRROR/$REPO/os/$ARCH/" |sed  -n "s|.*href=\"\\([^\"]*\\).*|$MIRROR\\/$REPO\\/os\\/$ARCH\\/\\1|p"|grep -v 'sig$'|uniq >> $LIST 
 +
done
 +
# Download and extract each package.
 +
for PACKAGE in ${PACKAGES[*]}; do
 +
        URL=`grep "$PACKAGE-[0-9]" $LIST|head -n1`
 +
        FILE=`echo $URL|sed 's/.*\/\([^\/][^\/]*\)$/\1/'`
 +
        wget "$URL" -c -O "$DIR/$FILE"
 +
        xz -dc "$DIR/$FILE" | tar x -k -C "$CHROOT_DIR"
 +
done
 +
# Create mount points
 +
mkdir -p "$CHROOT_DIR/dev" "$CHROOT_DIR/proc" "$CHROOT_DIR/sys" "$CHROOT_DIR/mnt"
 +
mount -t proc proc "$CHROOT_DIR/proc/"
 +
mount -t sysfs sys "$CHROOT_DIR/sys/"
 +
mount -o bind /dev "$CHROOT_DIR/dev/"
 +
mkdir -p "$CHROOT_DIR/dev/pts"
 +
mount -t devpts pts "$CHROOT_DIR/dev/pts/"
  
1) La partición de repuesto puede ser reclamada para hacer un sistema de archivos con "mkreiserfs", "mke2fs", etc dev/hda12 Usando como ejemplo:
+
# Hash for empty password  Created by doing: openssl passwd -1 -salt ihlrowCo and entering an empty password (just press enter)
mkreiserfs / dev/hda12
+
echo 'root:$1$ihlrowCo$sF0HjA9E8up9DYs258uDQ0:10063:0:99999:7:::' > "$CHROOT_DIR/etc/shadow"
 +
echo "root:x:0:0:root:/root:/bin/bash" > "$CHROOT_DIR/etc/passwd"
 +
touch "$CHROOT_DIR/etc/group"
 +
echo "myhost" > "$CHROOT_DIR/etc/hostname"
 +
test -e "$CHROOT_DIR/etc/mtab" || echo "rootfs / rootfs rw 0 0" > "$CHROOT_DIR/etc/mtab"
 +
[ -f "/etc/resolv.conf" ] && cp "/etc/resolv.conf" "$CHROOT_DIR/etc/"
 +
sed -ni '/^[ \t]*CheckSpace/ !p' "$CHROOT_DIR/etc/pacman.conf"
 +
sed -i "s/^[ \t]*SigLevel[ \t].*/SigLevel = Never/" "$CHROOT_DIR/etc/pacman.conf"
 +
echo "Server = $MIRROR/\$repo/os/$ARCH" >> "$CHROOT_DIR/etc/pacman.d/mirrorlist"
  
2) A continuación, edite / etc / fstab para verificar la partición del sistema de archivo correcto y las opciones que figuran en su contra:
+
chroot $CHROOT_DIR /usr/bin/pacman -Sy
/dev/hda12 /mnt/spare reiserfs defaults,noatime,notail,noauto 0 0
+
chroot $CHROOT_DIR /bin/bash
 +
</nowiki>}}
  
3) Por último comprobar que el punto de montaje existe, si no:
+
===Utilizar el entorno chroot===
  mkdir /mnt/spare
+
 
 +
====Inicializar pacman keyring====
 +
 
 +
Antes de iniciar la instalación, las claves de pacman deben ser configuradas. Antes de ejecutar las siguientes órdenes lea  [[pacman-key#Initializing the keyring]] para entender el proceso:
 +
{{bc|
 +
# pacman-key --init
 +
# pacman-key --populate archlinux
 +
}}
 +
 
 +
====Instalación====
 +
 
 +
Siga la [[Installation Guide (Español)|guía para principiantes]] sobre [[Installation_Guide_(Español)#Montar_las_particiones|Montar las particiones]] e [[Installation_Guide_(Español)#Instalaci.C3.B3n_del_sistema_base|Instalar el sistema base]].
 +
 
 +
=====Anfitrión basado en Debian=====
 +
 
 +
En los sistemas basados en Debian, {{ic|pacstrap}} arroja el siguiente error:
 +
# pacstrap /mnt base
 +
# ==> Creating install root at /mnt
 +
# mount: mount point /mnt/dev/shm is a symbolic link to nowhere
 +
# ==> ERROR: failed to setup API filesystems in new root
 +
 
 +
En Debian, los puntos de /dev/shm a /run/shm. Sin embargo, en el chroot basado en Arch, /run/shm no existe y el enlace está roto. Para corregir este error, cree un directorio /run/shm:
 +
  # mkdir /run/shm
 +
 
 +
====Configurar el sistema====
 +
 
 +
A partír de aquí, basta con seguir la [[Installation Guide (Español)|guía para principiantes]] desde [[Installation_Guide_(Español)#Montar_las_particiones|Montar las particiones]].
 +
 
 +
==Alternativa: Instalación de los arch-install-scripts nativos en una distribución que no sea Arch==
 +
 
 +
{{Deletion|Este método es excesivo después de que Arch proporciona la imagen Bootstrap.}}
 +
{{Advertencia|Este método puede ser difícil, su experiencia puede variar de una distro a otra.}}
 +
 
 +
==== Descargar el código fuente de pacman y los paquetes de pacman ====
 +
 
 +
Visite la página principal de pacman: https://www.archlinux.org/pacman/#_releases y descargue la última versión.
 +
 
 +
Ahora, descarge los paquetes siguientes:
 +
 
 +
* pacman-mirrorlist: https://www.archlinux.org/packages/core/any/pacman-mirrorlist/download/
 +
* arch-install-scripts: https://www.archlinux.org/packages/extra/any/arch-install-scripts/download/
 +
* pacman (necesario para los archivos de configuración): https://www.archlinux.org/packages/core/x86_64/pacman/download/ (cambie x86_64 si es necesario)
 +
 
 +
==== Instalación de dependencias ====
 +
 
 +
Usando los mecanismos de su distribución, instale los paquete requeridos por pacman e instale los scripts de instalación de Arch. libcurl, libarchive, fakeroot, xz, asciidoc, wget, y sed están entre ellos. Por supuesto, gcc, make y maybe son otros paquetes del grupo «devel» también necesarios.
 +
 
 +
==== Compilar pacman ====
 +
 
 +
* Descomprima el código fuente de pacman y muévase al directorio donde lo ha descomprimido.
 +
* Ejecute configure, adaptando las rutas según su conveniencia: {{bc|<nowiki> ./configure --prefix=/usr --sysconfdir=/etc --localstatedir=/var --enable-doc</nowiki>}}
 +
Si obtiene errores aquí, lo más probable es que falten dependencias, o su actual libcurl, libarchive u otros, son demasiado viejos. Instale las dependencias que falten utilizando las opciones de su distribución o, si son demasiado viejas, compile desde las fuentes.
 +
* Compile {{bc|make}}
 +
* Si no hay errores , instale los archivos {{bc|make install}}
 +
* Es posible que tenga que llamar manualmente a {{ic|ldconfig}} para que su distribución detecte libalpm.
 +
 
 +
==== Preparar los archivos de configuración ====
 +
 
 +
Ahora es el momento de extraer los archivos de configuración. Cambie x86_64 si es necesario.
 +
* Extraiga pacman.conf y makepkg.conf del paquete pacman, y desactive la comprobación de las firmas: {{bc|<nowiki>tar xJvf pacman-*-x86_64.pkg.tar.xz etc -C / ; sed -i 's/SigLevel.*/SigLevel = Never/g' /etc/pacman.conf</nowiki>}}
 +
* Extraiga la lista de servidores de réplica: {{bc|tar xJvf pacman-mirrorlist-*-any.pkg.tar.xz -C /}}
 +
* Active algunos servidores de réplica en {{ic|/etc/pacman.d/mirrorlist}}
 +
* Extraiga arch-install-scripts {{bc|tar xJvf arch-install-scripts-*-any.pkg.tar.xz -C /}}
 +
 
 +
Otra opción es usar la herramienta {{ic|alien}} para convertir {{ic|pacman-mirrorlist}} y {{ic|arch-install-scripts}} (pero sin {{ic|pacman}}) para paquetes nativos de su distribución.
 +
 
 +
==Sustituir el sistema existente sin un LiveCD==
 +
 
 +
Encuentre ~500MB de espacio libre en el disco, por ejemplo, redimensionando una partición swap.
 +
Instale el nuevo sistema Arch Linux, reinicie desde el sistema recién creado, y realice un  [[Full_System_Backup_with_rsync#With_a_single_command|rsync del sistema completo]] para la partición primaria.
 +
Fije la configuración del gestor de arranque antes de reiniciar.

Revision as of 12:34, 8 November 2013


Este documento describe el proceso de bootstrapping necesario para instalar Arch Linux desde un sistema anfitrión de Linux en ejecución. Después del bootstrapping, la instalación continúa como se describe en la guía de instalación.

La instalación de Arch Linux desde un sistema Linux en ejecución es útil para:

El objetivo del procedimiento de bootstrapping es configurar un entorno desde el que ejecutar los arch-install-scripts (tales como pacstrap y arch-root). Este objetivo se logra mediante la instalación de los arch-install-scripts nativos en un sistema anfitrión, o configurando un entorno chroot basado en Arch Linux.

Si el sistema anfitrión ejecuta Arch Linux, la instalación de los arch-install-scripts es sencilla.

Desde otras distribuciones, el proceso es más complicado (el cual se describe en #Alternativa: Instalación de los arch-install-scripts nativos en una distribución que no sea Arch). Para estas distribuciones, se recomienda la creación de un entorno chroot en su lugar.

Nota: Esta guía requiere que el sistema anfitrión existente sea capaz de ejecutar los nuevos programas de Arch Linux para la arquitectura de destino. En el caso de un anfitrión x86_64, es posible utilizar i686-Pacman para construir un entorno chroot de 32 bits. Véase Arch64 Install bundled 32bit system. Sin embargo, no es tan fácil construir un entorno de 64 bits cuando el anfitrión solo permite ejecutar programas de 32 bits.

Efectuar chroot basado en Arch Linux

La idea es ejecutar un sistema Arch en el sistema anfitrión. La instalación en curso se ejecuta desde este sistema Arch. Este sistema anidado está contenido dentro de un entorno chroot. Existen tres métodos para configurar e introducirnos en un entorno chroot, que se presentan a continuación, desde el más sencillo hasta el más complejo.

Nota: Su sistema anfitrión debe ejecutar Linux 2.6.32 o superior

Método 1: Utilizar la imagen Bootstrap

Descargue la imagen Bootstrap desde un servidor de réplica:

 curl -O http://www.gtlib.gatech.edu/pub/archlinux/iso/2013.10.01/archlinux-bootstrap-2013.10.01-x86_64.tar.gz

Extraiga el archivo tar:

 # cd /tmp
 # tar xzf <path-to-bootstrap-image>/archlinux-bootstrap-2013.10.01-x86_64.tar.gz

Seleccione un servidor de repositorio:

 # nano /tmp/root.x86_64/etc/pacman.d/mirrorlist

Entre en el entorno chroot:

  • Si tiene bash 4 o superior instalado:
  # /tmp/root.x86_64/bin/arch-chroot /tmp/root.x86_64/
  • Después ejecute las órdenes suiguientes:
  # cp /etc/resolv.conf /tmp/root.x86_64/etc
  # mount --rbind /proc /tmp/root.x86_64/proc
  # mount --rbind /sys /tmp/root.x86_64/sys
  # mount --rbind /dev /tmp/root.x86_64/dev
  # mount --rbind /run /tmp/root.x86_64/run
    (presumiento que /run exista en su sistema)
  # chroot /tmp/root.x86_64/

Método 2: Utilizar la imagen del LiveCD

Es posible montar la imagen root con el soporte de instalación de Arch Linux más reciente y luego efectuar chroot en él. Este método tiene la ventaja de que proporciona una instalación de Arch Linux funcionando bien dentro de su sistema anfitrión, sin necesidad de prepararlo mediante la instalación de paquetes específicos.

Nota: Antes de continuar, asegúrese de que la última versión de squashfs está instalada en el sistema anfitrión. De lo contrario, se producirán errores como: FATAL ERROR aborting: uncompress_inode_table: failed to read block.
  • La imagen root se puede encontrar en uno de los servidores de réplica, disponible tanto para arquitecturas x86_64 como i686, dependiendo de sus necesidades.El formato squashfs no es editable, así que efectuaremos unsquash de la imagen root y luego la monteremos.
  • Para efectuar unsquash de la imagen root, ejecute:
# unsquashfs -d /squashfs-root root-image.fs.sfs
  • Ahora se puede montar la imagen root con la opción loop:
# mkdir /arch
# mount -o loop /squashfs-root/root-image.fs /arch
  • Antes de enjaularlo, tenemos que establecer algunos puntos de montaje y copiar el archivo resolv.conf para las conexiones de red:
# mount -t proc none /arch/proc
# mount -t sysfs none /arch/sys
# mount -o bind /dev /arch/dev
# mount -o bind /dev/pts /arch/dev/pts # important for pacman (for signature check)
# cp -L /etc/resolv.conf /arch/etc #this is needed to use networking within the chroot
  • Ahora está todo preparado para enjaular (efectuar chroot) el entorno donde Arch se va a instalar:
# chroot /arch bash

Método 3: Montar manulamente el entorno chroot (con un script)

El script crea un directorio llamado archinstall-pkg y descarga los paquetes necesarios en él. A continuación, los extrae al directorio archinstall-chroot. Por último, prepara los puntos de montaje, configura pacman y enjaula el entorno.

archinstall-bootstrap.sh
#!/bin/bash
# This script is inspired on the archbootstrap script.

PACKAGES=(acl attr bzip2 curl expat glibc gpgme gnupg libarchive libassuan libgcrypt libgpg-error libssh2 lzo2 openssl pacman xz zlib pacman-mirrorlist coreutils bash grep gawk file filesystem tar ncurses readline libcap util-linux pcre arch-install-scripts)
# Change the mirror as necessary
MIRROR='http://mirrors.kernel.org/archlinux' 
# You can set the ARCH variable to i686 or x86_64
ARCH=`uname -m`
LIST=`mktemp`
CHROOT_DIR=archinstall-chroot
DIR=archinstall-pkg
mkdir -p "$DIR"
mkdir -p "$CHROOT_DIR"
# Create a list with urls for the arch packages
for REPO in core community extra; do  
        wget -q -O- "$MIRROR/$REPO/os/$ARCH/" |sed  -n "s|.*href=\"\\([^\"]*\\).*|$MIRROR\\/$REPO\\/os\\/$ARCH\\/\\1|p"|grep -v 'sig$'|uniq >> $LIST  
done
# Download and extract each package.
for PACKAGE in ${PACKAGES[*]}; do
        URL=`grep "$PACKAGE-[0-9]" $LIST|head -n1`
        FILE=`echo $URL|sed 's/.*\/\([^\/][^\/]*\)$/\1/'`
        wget "$URL" -c -O "$DIR/$FILE" 
        xz -dc "$DIR/$FILE" | tar x -k -C "$CHROOT_DIR"
done
# Create mount points
mkdir -p "$CHROOT_DIR/dev" "$CHROOT_DIR/proc" "$CHROOT_DIR/sys" "$CHROOT_DIR/mnt"
mount -t proc proc "$CHROOT_DIR/proc/"
mount -t sysfs sys "$CHROOT_DIR/sys/"
mount -o bind /dev "$CHROOT_DIR/dev/"
mkdir -p "$CHROOT_DIR/dev/pts"
mount -t devpts pts "$CHROOT_DIR/dev/pts/"

# Hash for empty password  Created by doing: openssl passwd -1 -salt ihlrowCo and entering an empty password (just press enter)
echo 'root:$1$ihlrowCo$sF0HjA9E8up9DYs258uDQ0:10063:0:99999:7:::' > "$CHROOT_DIR/etc/shadow"
echo "root:x:0:0:root:/root:/bin/bash" > "$CHROOT_DIR/etc/passwd" 
touch "$CHROOT_DIR/etc/group"
echo "myhost" > "$CHROOT_DIR/etc/hostname"
test -e "$CHROOT_DIR/etc/mtab" || echo "rootfs / rootfs rw 0 0" > "$CHROOT_DIR/etc/mtab"
[ -f "/etc/resolv.conf" ] && cp "/etc/resolv.conf" "$CHROOT_DIR/etc/"
sed -ni '/^[ \t]*CheckSpace/ !p' "$CHROOT_DIR/etc/pacman.conf"
sed -i "s/^[ \t]*SigLevel[ \t].*/SigLevel = Never/" "$CHROOT_DIR/etc/pacman.conf"
echo "Server = $MIRROR/\$repo/os/$ARCH" >> "$CHROOT_DIR/etc/pacman.d/mirrorlist"

chroot $CHROOT_DIR /usr/bin/pacman -Sy 
chroot $CHROOT_DIR /bin/bash

Utilizar el entorno chroot

Inicializar pacman keyring

Antes de iniciar la instalación, las claves de pacman deben ser configuradas. Antes de ejecutar las siguientes órdenes lea pacman-key#Initializing the keyring para entender el proceso:

# pacman-key --init
# pacman-key --populate archlinux

Instalación

Siga la guía para principiantes sobre Montar las particiones e Instalar el sistema base.

Anfitrión basado en Debian

En los sistemas basados en Debian, pacstrap arroja el siguiente error:

# pacstrap /mnt base
# ==> Creating install root at /mnt
# mount: mount point /mnt/dev/shm is a symbolic link to nowhere
# ==> ERROR: failed to setup API filesystems in new root

En Debian, los puntos de /dev/shm a /run/shm. Sin embargo, en el chroot basado en Arch, /run/shm no existe y el enlace está roto. Para corregir este error, cree un directorio /run/shm:

# mkdir /run/shm

Configurar el sistema

A partír de aquí, basta con seguir la guía para principiantes desde Montar las particiones.

Alternativa: Instalación de los arch-install-scripts nativos en una distribución que no sea Arch

Tango-edit-cut.pngThis section is being considered for removal.Tango-edit-cut.png

Reason: Este método es excesivo después de que Arch proporciona la imagen Bootstrap. (Discuss in Talk:Install from existing Linux (Español)#)
Advertencia: Este método puede ser difícil, su experiencia puede variar de una distro a otra.

Descargar el código fuente de pacman y los paquetes de pacman

Visite la página principal de pacman: https://www.archlinux.org/pacman/#_releases y descargue la última versión.

Ahora, descarge los paquetes siguientes:

Instalación de dependencias

Usando los mecanismos de su distribución, instale los paquete requeridos por pacman e instale los scripts de instalación de Arch. libcurl, libarchive, fakeroot, xz, asciidoc, wget, y sed están entre ellos. Por supuesto, gcc, make y maybe son otros paquetes del grupo «devel» también necesarios.

Compilar pacman

  • Descomprima el código fuente de pacman y muévase al directorio donde lo ha descomprimido.
  • Ejecute configure, adaptando las rutas según su conveniencia:
     ./configure --prefix=/usr --sysconfdir=/etc --localstatedir=/var --enable-doc

Si obtiene errores aquí, lo más probable es que falten dependencias, o su actual libcurl, libarchive u otros, son demasiado viejos. Instale las dependencias que falten utilizando las opciones de su distribución o, si son demasiado viejas, compile desde las fuentes.

  • Compile
    make
  • Si no hay errores , instale los archivos
    make install
  • Es posible que tenga que llamar manualmente a ldconfig para que su distribución detecte libalpm.

Preparar los archivos de configuración

Ahora es el momento de extraer los archivos de configuración. Cambie x86_64 si es necesario.

  • Extraiga pacman.conf y makepkg.conf del paquete pacman, y desactive la comprobación de las firmas:
    tar xJvf pacman-*-x86_64.pkg.tar.xz etc -C / ; sed -i 's/SigLevel.*/SigLevel = Never/g' /etc/pacman.conf
  • Extraiga la lista de servidores de réplica:
    tar xJvf pacman-mirrorlist-*-any.pkg.tar.xz -C /
  • Active algunos servidores de réplica en /etc/pacman.d/mirrorlist
  • Extraiga arch-install-scripts
    tar xJvf arch-install-scripts-*-any.pkg.tar.xz -C /

Otra opción es usar la herramienta alien para convertir pacman-mirrorlist y arch-install-scripts (pero sin pacman) para paquetes nativos de su distribución.

Sustituir el sistema existente sin un LiveCD

Encuentre ~500MB de espacio libre en el disco, por ejemplo, redimensionando una partición swap. Instale el nuevo sistema Arch Linux, reinicie desde el sistema recién creado, y realice un rsync del sistema completo para la partición primaria. Fije la configuración del gestor de arranque antes de reiniciar.