¿Cómo puedo crear una distribución personalizada para ejecutar un navegador web simple?

Estamos ensamblando algunas máquinas livianas con el propósito expreso de mostrar una sola página web en una pantalla grande. Necesito que la máquina se inicie esencialmente de la manera más ligera y rápida posible y esencialmente haga que ejecute un navegador (¿WebKit?) En pantalla completa, cargando una página que JavaScript controlará dinámicamente. Usaré un procesador Intel D525 de doble núcleo con GPU integrada, por lo que no debería necesitar configurar ningún controlador de gráficos propietario. Una vez que configure una de estas máquinas correctamente, debería poder cargar ddel disco duro en mi computadora y luego volcarlo en cada nueva máquina.

Tengo las siguientes preguntas:

1. ¿Cómo puedo crear una "distribución" que incluya solo lo que necesito? Supongo que necesitaré el kernel (;]), X y un navegador web de algún tipo, pero en realidad no mucho más. ¿Podría tomar algo como Ubuntu Server y simplemente instalar X Server y encontrar la manera de que la máquina inicie sesión automáticamente, inicie X e inicie el navegador web, sin hacer preguntas? ¿Hay un libro que pueda leer o un artículo o algo?

2. ¿Qué puedo usar para un navegador web agradable y sencillo que esencialmente ejecute un "Chromium sin cromo"? Estas máquinas no aceptarán la entrada del usuario en absoluto. Si necesito administrarlos, usaré SSH.

Muchas distribuciones tienen alguna facilidad para una instalación mínima; esencialmente donde selecciona manualmente solo aquellos paquetes que desea instalar explícitamente. Debian tiene esta capacidad y sería una mejor opción, en su situación, que el otro contendiente mínimo obvio, Arch Linux.

El estado de lanzamiento continuo de Arch puede proporcionar un nivel de complejidad continua que desea evitar. Debian proporcionaría la base simple y mínima que está buscando, además de ofrecer estabilidad. Hay una publicación de blog sobre el uso de Debian como quiosco que puede ofrecer algunos consejos útiles.

Para un navegador, como beav_35 sugiere, Uzbl es una opción buena. Mi recomendación sería Vimprobable , un navegador WebKit que es programable, controlado por teclado y que puede controlarse de manera efectiva a través de SSH.

Como administrador de ventanas, recomendaría dwm : con menos de 2000 SLOC, es extremadamente liviano y se puede configurar fácilmente para una configuración de tipo quiosco.

En primer lugar, es posible que no desee reinventar la rueda ... Hay varias distribuciones centradas en el quiosco. Uno de esos puede ahorrarte mucho trabajo.

En segundo lugar, si está familiarizado con Kickstart en Fedora y RHEL (o CentOS o Scientific Linux), puede usar las herramientas de Fedora para hacer su propio giro de cualquiera de esas distribuciones. La documentación está un poco dispersa, pero comienza aquí .

Comience con una distribución mínima como Arch Linux , luego instale los paquetes que necesita. Para un navegador web simple, prueba Uzbl .

Esta es una pregunta bastante complicada, y dado que su proyecto no está del todo claro, algunas de estas sugerencias pueden estar fuera de lugar, pero considérelas como cosas para evaluar.

• Es posible que no necesite un navegador web en cualquier computadora que sea parte de la matriz de visualización. Si está intentando mostrar una sola página en muchas pantallas, es probable que desee utilizar algún tipo de tecnología de visualización masiva. Hay varias variantes de Xorg que se especializan en generar una gran pantalla a partir de dispositivos de video en varias máquinas.

• Incluso si usa servidores X separados en cada máquina, puede usar el reenvío X para enviar datos de visualización desde una o más computadoras, por lo que los navegadores aún no tendrían que ejecutarse localmente.

• No querrá usar ningún administrador de ventanas y usar especificaciones de geometría para iniciar la pantalla completa de su aplicación, o usar un mosaico configurable o un administrador de ventanas de marco (como awesome) para administrar las ventanas en cada pantalla X. Esto facilita la clasificación y el control de ventanas de pantalla completa y es altamente programable.

• En cuanto a un navegador, creo que uzbles una opción clara.

• Esta podría ser una buena aplicación para el arranque de red. Puede configurar el servidor con un núcleo de netbook disponible a través de TFTP y un sistema de archivos disponible a través de nfs. Todo lo que sus clientes deben hacer es usar una NIC con arranque de red para contactar a este servidor, descargar su núcleo y listo. No hay disco duro involucrado! Y fácil mantenimiento. Todas las máquinas pueden potencialmente arrancar la misma imagen.

• Su "distribución" probablemente debería consistir en dos cosas. 1) Un conjunto de paquetes y 2) un conjunto de archivos de configuración. El conjunto de paquetes es una lista de paquetes que deben instalarse. Esto generalmente se puede ensamblar en un archivo de texto y luego puede usar la mayoría de los administradores de paquetes de la distribución para instalar esta lista de paquetes en un destino (ya sea un disco duro o un directorio que será su punto de montaje nfs). Los archivos de configuración probablemente deberían mantenerse en gitotro sistema de control de fuente y contener algunos scripts y cualquier modificación de configuración que deba realizarse en el sistema base instalado con el conjunto de paquetes. Construir un nuevo sistema se convierte en:

  • Montar unidad o directorio de destino
  • package_manager --install-distro --package-set=/path/packagelist.txt --target=/path
  • cd /target/path
  • git clone /path/to/repo (o de lo contrario, verifique su código de configuración en la raíz del sistema)
  • Instale el gestor de arranque si la unidad o agregue la configuración PXE si el arranque de red
  • bota.

La distribución que use como base dependerá de con qué se sienta más cómodo. Me gustaría utilizar PLD-Linux para mí, pero probablemente lo recomendaría Arch Linux como un sistema similar pero mejor documentado para un novato de trabajar. No hay razón para que Debian , Fedora o Gentoo no funcionen para esto.

Buildroot 2016.05 + Midori

Buildroot es una gran herramienta para construir distribuciones mínimas:

• le das un .configarchivo
• descarga y compila todo el software requerido y las dependencias, y produce una imagen

Midori es un navegador minimalista basado en WebKit , y Buildroot tiene un paquete Midori incorporado.

.configarchivo utilizado: https://github.com/cirosantilli/buildroot-configs/blob/32d1174e0bf8d00b92323eebe8901af3f8c389d3/2016.05/qemu_x86_64_x11_midori_defconfig

Cómo generar ese archivo de configuración:

1. Seguir: ¿Cómo instalar X11 en mi propio sistema Linux Buildroot? El | Unix y Linux Stack Exchange para crear una imagen con X11.
2. make menuconfig
   1. Cadena de herramientas
      1. Biblioteca C
         1. glibc (para midori)
   2. Paquetes de destino
      1. Bibliotecas gráficas y aplicaciones
         1. mesa3d
            1. seleccione todos los controladores Gallium y DRI ya que no entiendo cuál es necesario (para OpenGL EGL)
            2. OpenGL EGL (para libgtk3)
      2. Bibliotecas
         1. Gráficos 1. libgtk3 (para midori)

Limpia la compilación porque cambiamos la cadena de herramientas y compila nuevamente:

rm -rf output
make BR2_JLEVEL=$(nproc)

Espera horas Entonces lo de siempre:

qemu-system-x86_64 \
    -enable-kvm \
    -M pc \
    -m 512 \
    -kernel output/images/bzImage \
    -drive file=output/images/rootfs.ext2,if=virtio,format=raw \
    -append root=/dev/vda \
    -net nic,model=virtio \
    -net user

Y desde adentro QEMU:

root
startx

y desde la GUI X11, haga clic en una xtermventana y ejecute:

midori

Salir:

Tamaño de imagen: 220M! Compare eso con los 28M de un sistema X11 simple ¿Cómo instalar X11 en mi propio sistema Linux Buildroot? - Intercambio de pila de Unix y Linux . Probablemente debido a las dependencias de WebKit + GTK3.

Probado en el host Ubuntu 16.04, QEMU 2.5.0.

NetSurf

Escrito en SDL, que admite el fbdev: http://www.netsurf-browser.org/about/screenshots/#framebuffer

fbdev es una interfaz de nivel inferior que ofrece un módulo de kernel de Linux que no pasa por X11 (creo que X11 puede usarlo opcionalmente como back-end). Básicamente solo escribes en la memoria y se muestra en la pantalla.

Para usar fbdev en Ubuntu, debe estar en un TTY (por ejemplo, Ctrl + Alt + F1).

Entonces, probablemente pueda salirse con una imagen mucho más pequeña que la de Midori.

Buildroot 2016.05 tiene un paquete netsurf-buildsystemque debería proporcionarlo, pero no lo he probado. Si alguien logra que se ejecute, edítelo en un enlace a una configuración, captura de pantalla y tamaño de imagen.

Una vez escribí un pequeño script bash que toma un ISO de Arch Linux y genera un nuevo ISO con una imagen raíz modificada que hace una instalación totalmente automatizada. Esto incluye particionar, así como configurar y configurar el sistema con Xorg, FVWM y Chromium. El sistema instalado iniciará sesión automáticamente e iniciará Chromium. Simplemente coloque el nuevo ISO en una unidad flash USB y recuéstese. ;-)

Descargo de responsabilidad: el script se proporciona tal cual, sin garantía. No lo he usado en mucho tiempo, por lo que podría necesitar un ajuste aquí o allá. Modifique según sea necesario.

#!/bin/bash
# Helpful pages:
#
#   * [ArchWiki topic][1] that explains the options of an AIF configuration
#     file.
#
#   * [Status of automated installation][2], a topic in the Arch Linux Forums
#     that contains the original basic install script by *mhertz*.
#
# [1]: https://wiki.archlinux.org/index.php/AIF_Configuration_File
# [2]: https://bbs.archlinux.org/viewtopic.php?id=111925

TMP_DIR=/tmp/arch-install

# Read command line parameters for input and output ISO files.
if [ -z "$1" ]; then
    echo 'No input file specified, aborting.'
    exit 1
elif [ ! -f "$1" ]; then
    echo 'Input file "'$INPUT_ISO'" not found, aborting.'
    exit 1
elif [ -z "$2" ]; then
    echo 'No output file specified, aborting.'
    exit 1
elif [ -f "$2" ]; then
    echo 'Output file "'$OUTPUT_ISO'" already exists, aborting.'
    exit 1
fi

# Determine full paths to input and output ISO files.
INPUT_ISO=$(readlink -f "$1")
OUTPUT_ISO=$(readlink -f "$2")

# Set some variables for convenience.
SOURCE_DIR=$TMP_DIR/source
DEST_DIR=$TMP_DIR/dest
ROOT_DIR=$TMP_DIR/squashfs-root
BOOT_CFG=$DEST_DIR/boot/isolinux/isolinux.cfg

# Extract ISO image and root image.
mkdir -p $SOURCE_DIR
mount -o loop "$INPUT_ISO" $SOURCE_DIR
cp -a $SOURCE_DIR $DEST_DIR
umount $SOURCE_DIR
rmdir $SOURCE_DIR
unsquashfs -d $ROOT_DIR $DEST_DIR/root-image.sqfs
rm $DEST_DIR/root-image.sqfs

# Modify the root image as needed.
cat >> $ROOT_DIR/etc/aif.conf <<EOF
SOURCE=cd
FILE_URL=file:///src/core/pkg
SYNC_URL=http://ftp.tu-chemnitz.de/pub/linux/archlinux/\$repo/os/\$arch
HARDWARECLOCK=UpTC
TIMEZONE=Europe/Vienna
RUNTIME_REPOSITORIES=
RUNTIME_PACKAGES=
TARGET_GROUPS=base
TARGET_PACKAGES_EXCLUDE=
TARGET_PACKAGES='openssh xorg xcursor-vanilla-dmz-aa'

worker_runtime_network () {
    dhcpcd eth0
}

worker_configure_system () {
    prefill_configs
    sed -i '/^HOSTNAME/ s/"myhost"/"arch"/' \$var_TARGET_DIR/etc/rc.conf
    sed -i '/^password/ s/pam_permit\.so/pam_unix.so md5 shadow/' \$var_TARGET_DIR/etc/pam.d/chpasswd
    sed -i '\|Server = http://ftp\.tu-chemnitz\.de/| s/^#//' \$var_TARGET_DIR/etc/pacman.d/mirrorlist
    sed -i '/id:3:initdefault:/ s/^/#/' \$var_TARGET_DIR/etc/inittab
    sed -i '/id:5:initdefault:/ s/^#//' \$var_TARGET_DIR/etc/inittab
    sed -i '\|x:5:respawn:/usr/bin/xdm| s/^/#/' \$var_TARGET_DIR/etc/inittab
    echo "x:5:respawn:/bin/su -l -c '/usr/bin/startx </dev/null >/dev/null 2>&1' myuser" >> \$var_TARGET_DIR/etc/inittab
    sed -i 's/^timeout .*$/timeout 0/' \$var_TARGET_DIR/boot/grub/menu.lst
    cp /etc/rc.local.firstboot \$var_TARGET_DIR/etc/rc.local
}

# Mandatory variables.
GRUB_DEVICE=/dev/sda
PARTITIONS='/dev/sda 20:ext2:+ 512:swap 2500:xfs *:xfs'
BLOCKDATA='/dev/sda1 raw no_label ext2;yes;/boot;target;no_opts;no_label;no_params
/dev/sda2 raw no_label swap;yes;no_mountpoint;target;no_opts;no_label;no_params
/dev/sda3 raw no_label xfs;yes;/;target;no_opts;no_label;no_params
/dev/sda4 raw no_label xfs;yes;/home;target;no_opts;no_label;no_params'
EOF

cat >> $ROOT_DIR/etc/rc.local <<EOF
aif -p automatic -c /etc/aif.conf
reboot
EOF

cat >> $ROOT_DIR/etc/rc.local.firstboot <<EOF
echo root:rootpassword | chpasswd
useradd -m myuser
echo myuser:myuser | chpasswd
cat >> /home/myuser/.xinitrc <<EOT
#!/bin/sh
exec fvwm2
EOT
cat >> /home/myuser/.Xdefaults <<EOT
Xcursor.theme: Vanilla-DMZ-AA
EOT
mkdir -p /home/myuser/.fvwm
cat >> /home/myuser/.fvwm/config <<EOT
DeskTopSize 1x1
DesktopName 0 Main
DestroyFunc StartFunction
AddToFunc StartFunction
 + I Test (Init) Exec exec xsetroot -solid '#303030'
 + I Test (Init) Exec exec chromium 'http://www.stackoverflow.com'
DestroyMenu RootMenu
AddToMenu RootMenu "Menu" Title
 + "Terminal" Exec exec xterm
 + "Browser" Exec exec chromium 'https://www.stackoverflow.com'
 + "" Nop
 + "Log off" Quit
 + "Reboot" Exec exec sudo /sbin/reboot
 + "Shutdown" Exec exec sudo /sbin/halt
OpaqueMoveSize unlimited
Style * ClickToFocus, ResizeOpaque
Style chromium !Title, !Border, !Handles
CursorStyle root top_left_arrow
CursorStyle stroke hand2
IgnoreModifiers L25
Key Help R A -
Key F1 R A -
Key Tab A M -
Key Escape A MC -
Mouse 1 R A -
Mouse 1 T A Move
Mouse 1 FS A Resize
Mouse 1 I A Iconify Off
Mouse 2 FST A -
Mouse 3 R A Menu RootMenu Nop
EOT
mkdir -p /home/myuser/.config/chromium/Default
touch /home/myuser/.config/chromium/First\ Run
cat >> /home/myuser/.config/chromium/Default/Preferences <<EOT
{
   "alternate_error_pages": {
      "enabled": false
   },
   "autofill": {
      "enabled": false
   },
   "browser": {
      "custom_chrome_frame": true,
      "enable_spellchecking": false
   },
   "default_search_provider": {
       "enabled": true,
       "encodings": "UTF-8",
       "icon_url": "about:blank",
       "id": "2",
       "instant_url": "",
       "keyword": "google.com",
       "name": "Google",
       "prepopulate_id": "1",
       "search_url": "{google:baseURL}search?ie={inputEncoding}&q={searchTerms}",
       "suggest_url": ""
   },
   "devtools": {
      "disabled": true
   },
   "dns_prefetching": {
      "enabled": false
   },
   "download": {
      "directory_upgrade": true
   },
   "extensions": {
      "chrome_url_overrides": {
         "bookmarks": [ "chrome-extension://eemcgdkfndhakfknompkggombfjjjeno/main.html" ]
      }
   },
   "geolocation": {
      "default_content_setting": 2
   },
   "google": {
      "services": {
         "username": ""
      }
   },
   "homepage": "https://www.stackoverflow.com",
   "homepage_is_newtabpage": false,
   "intl": {
      "accept_languages": "en",
      "charset_default": "ISO-8859-1"
   },
   "ntp": {
      "pref_version": 3
   },
   "profile": {
      "clear_site_data_on_exit": true,
      "content_settings": {
         "pref_version": 1
      },
      "default_content_settings": {
         "plugins": 1
      },
      "exited_cleanly": true,
      "notifications_default_content_setting": 2,
      "password_manager_enabled": false
   },
   "safebrowsing": {
      "enabled": false
   },
   "search": {
      "suggest_enabled": false
   },
   "tabs": {
      "use_vertical_tabs": false
   },
   "translate": {
      "enabled": false
   }
}
EOT
chown -R myuser:myuser /home/myuser
pacman -Sy
pacman -S --noconfirm pacman
pacman -S --noconfirm fvwm-devel chromium sudo
echo 'myuser arch=NOPASSWD: /sbin/halt,/sbin/reboot' > /etc/sudoers.d/start_stop
chmod 0440 /etc/sudoers.d/start_stop
rm /etc/rc.local
EOF

# Create the new root image.
mksquashfs $TMP_DIR/squashfs-root $TMP_DIR/dest/root-image.sqfs
rm -rf $TMP_DIR/squashfs-root

# Configure the boot loader.
sed -i 's/TIMEOUT 3000/TIMEOUT 100/' $BOOT_CFG
sed -i '/APPEND hd0 0/d' $BOOT_CFG
sed -i 's/archisolabel=[^ ]*/archisolabel=ARCH/' $BOOT_CFG

# Create the new ISO image.
genisoimage -l -R -b boot/isolinux/isolinux.bin -c boot/isolinux/boot.cat \
    -no-emul-boot -boot-load-size 4 -boot-info-table -V ARCH \
    -o "$OUTPUT_ISO" $DEST_DIR
rm -rf $TMP_DIR
isohybrid "$OUTPUT_ISO"

Para un sistema como este, recomendaría Puppy .

Si bien puede crear su distribución utilizando cualquier versión de Linux, Puppy hace que sea muy fácil crear imágenes de arranque personalizadas, está diseñada para ser compacta y tiene un excelente soporte de sistema de archivos de superposición.

Debería poder dd el disco duro

No, recomendaría crear una imagen de arranque que pueda mantener con sensatez; el enfoque que sugiera volverá y lo morderá.

• Varias personas mencionaron uzbl y estoy de acuerdo en que es una buena opción, pero es posible que encuentre luakit aún mejor.

• Como Caleb ya mencionó, realmente no necesita ningún administrador de ventanas. Aquí hay un script de ejemplo que diseñé para ejecutar un servidor Xorg sin WM con el navegador luakit maximizado:

  #!/bin/sh
  XDCMD="xdotool search --class luakit windowsize %3 100% 100%"
  while [ 1 ]
  do
      ( sleep 0.5; $XDCMD || sleep 0.2 && $XDCMD || sleep 5 && $XDCMD ) &
      /usr/bin/luakit $@
  done
  

  Utiliza el xdotool para maximizar la ventana justo después de que luakit ha comenzado. Tal vez hay una mejor solución para eso ...

• Para la base de dicho sistema, definitivamente recomendaría Gentoo. Eso no es solo porque lo conozco mejor;) sino también porque utiliza un enfoque bastante único de administrar globalmente las opciones de tiempo de compilación de todo el software instalado. Me refiero a las banderas USE . Al usarlos, usted determina el conjunto de características / bibliotecas / estándares que utilizan todos los programas que los admiten, por lo que, por ejemplo, si desea que sus programas usen ALSA y no necesite backends de audio adicionales como esd, jack o pulseaudio, usted poner alsa -jack -esd -pulseaudioentre sus banderas USE. Después de eso, cada pieza de software que construyas que puedautilizar backends de audio adicionales aparte de ALSA se construirá sin el soporte para esos. Como esto sucede en el nivel de configuración / compilación, terminas con un software significativamente más delgado. Entonces, esta es una filosofía de construcción (respetando todas las dependencias) en lugar de desmantelar (lo que puede terminar siendo defectuoso y muy difícil de mantener).

Mencionaré esto porque me sorprende que nadie más lo haya hecho.

Linux from Scratch es un libro (pdf) que lo guía a través de la creación de su propia distribución de Linux. Puede ser excesivo para lo que está tratando de lograr (en realidad, es porque ya tiene las herramientas que necesita), pero puede resultar una herramienta invaluable para comprender cómo funciona un sistema. Realmente no es tan difícil y no hay programación involucrada.