Como criar uma distribuição personalizada para executar um navegador da web simples?

Estamos montando algumas máquinas leves com o objetivo expresso de exibir uma única página da web em uma tela grande. Eu preciso que a máquina inicialize essencialmente o mais leve e o mais rápido possível e, essencialmente, execute um navegador (WebKit?) Em tela cheia, carregando uma página que será controlada dinamicamente por JavaScript. Usarei um processador Intel D525 de núcleo duplo com GPU integrada, portanto, não preciso configurar nenhum driver gráfico proprietário. Depois de instalar uma dessas máquinas corretamente, devo conseguir acessar ddo disco rígido do meu computador e despejá-lo em cada nova máquina.

Tenho as seguintes perguntas:

1. Como posso criar uma "distribuição" que inclua apenas o que eu preciso? Suponho que precisarei do kernel (;]), X e de um navegador da Web de algum tipo, mas não muito mais. Eu poderia pegar algo como o Ubuntu Server e simplesmente instalar o X Server e encontrar uma maneira de a máquina fazer login automaticamente, iniciar o X e iniciar o navegador da web, sem perguntas? Existe um livro que eu possa ler ou um artigo ou algo assim?

2. O que posso usar para um bom navegador despojado que essencialmente executa um "cromo sem cromo?" Essas máquinas não aceitarão a entrada do usuário. Se eu precisar gerenciá-los, usarei o SSH.

Muitas distribuições têm algumas facilidades para uma instalação mínima; essencialmente onde você seleciona manualmente apenas os pacotes que deseja instalar explicitamente. O Debian tem essa capacidade e seria uma escolha melhor, na sua situação, do que o outro candidato mínimo óbvio, o Arch Linux.

O status de liberação contínua do Arch pode fornecer um nível de complexidade contínua que você deseja evitar. O Debian forneceria a base simples e mínima que você procura, além de oferecer estabilidade. Há uma postagem no blog sobre o uso do Debian como um quiosque que pode oferecer algumas dicas úteis.

Para um navegador, como beav_35 sugere, Uzbl é uma boa escolha. Minha recomendação seria o Vimprobable , um navegador WebKit que pode ser script, controlado por teclado e pode ser controlado de forma eficaz pelo SSH.

Como gerenciador de janelas, eu recomendaria o dwm : com menos de 2000 SLOC, é extremamente leve e pode ser facilmente configurado para uma instalação do tipo quiosque.

Antes de tudo, você pode não querer reinventar a roda ... Existem várias distribuições focadas no quiosque. Um deles pode economizar muito trabalho.

Segundo, se você estiver familiarizado com o Kickstart no Fedora e RHEL (ou CentOS ou Scientific Linux), poderá usar as ferramentas do Fedora para fazer sua própria rotação de qualquer uma dessas distribuições. A documentação está um pouco dispersa, mas comece aqui .

Comece com uma distribuição mínima, como o Arch Linux , e instale os pacotes necessários. Para um navegador simples, tente o Uzbl .

Essa é uma pergunta bastante envolvente e, como o seu projeto não está totalmente claro, algumas dessas sugestões podem ser estranhas, mas considere essas coisas a serem avaliadas.

• Talvez você não precise de um navegador da Web em qualquer computador que faça parte da matriz de exibição. Se você está tentando mostrar uma única página em várias telas, é provável que queira usar algum tipo de tecnologia de exibição em massa. Existem várias variantes do Xorg que se especializam em gerar uma grande tela de dispositivos de vídeo em várias máquinas.

• Mesmo se você usar servidores X separados em cada máquina, poderá usar o encaminhamento X para enviar dados de exibição de um ou mais outros computadores, para que os navegadores ainda não precisem ser executados localmente.

• Você deseja não usar nenhum gerenciador de janelas e usar especificações de geometria para iniciar o aplicativo em tela cheia ou usar um awesomegerenciador de janelas configurável em bloco ou estrutura (como ) para gerenciar as janelas em cada exibição do X. Isso facilita a classificação e o controle das janelas de tela cheia e é altamente programável.

• Quanto a um navegador, acho que uzblé provavelmente a escolha certa .

• Esse pode ser um bom aplicativo para inicialização em rede. Você pode configurar o servidor com um kernel de netbook disponível via TFTP e um sistema de arquivos disponível via nfs. Tudo que seus clientes precisam fazer é usar uma NIC compatível com netboot para entrar em contato com este servidor, baixar o kernel e partir. Nenhum disco rígido envolvido! E manutenção fácil. Todas as máquinas podem potencialmente inicializar a mesma imagem.

• Sua "distribuição" provavelmente deve consistir em duas coisas. 1) Um conjunto de pacotes e 2) um conjunto de arquivos de configuração. O conjunto de pacotes é uma lista de pacotes que precisam ser instalados. Isso geralmente pode ser montado em um arquivo de texto e, em seguida, você pode usar a maioria dos gerenciadores de pacotes da distro para instalar essa lista de pacotes em um destino (um disco rígido ou um diretório que será o seu ponto de montagem nfs). Os arquivos de configuração provavelmente devem ser mantidos em gitou em outro sistema de controle de origem e conter alguns scripts e quaisquer mods de configuração que precisam ser feitos no sistema básico instalado com o conjunto de pacotes. A construção de um novo sistema se torna:

  • Montar unidade ou diretório de destino
  • package_manager --install-distro --package-set=/path/packagelist.txt --target=/path
  • cd /target/path
  • git clone /path/to/repo (ou faça o checkout do seu código de configuração na raiz do sistema)
  • Instale o carregador de inicialização se dirigir ou adicione a configuração PXE se o netboot
  • bota.

A distribuição que você usa como base deve depender do que você se sente mais confortável. Eu usaria o PLD-Linux para mim, mas provavelmente recomendo o ArchLinux como um sistema semelhante, mas melhor documentado, para um novato trabalhar. Não há razão para que o Debian , o Fedora ou o Gentoo não funcionem para isso.

Buildroot 2016.05 + Midori

O Buildroot é uma ótima ferramenta para criar distribuições mínimas:

• você dá um .configarquivo
• baixa e compila todo o software e dependências necessários e produz uma imagem

O Midori é um navegador minimalista baseado no WebKit e o Buildroot possui um pacote Midori embutido.

.configarquivo usado: https://github.com/cirosantilli/buildroot-configs/blob/32d1174e0bf8d00b92323eebe8901af3f8c389d3/2016.05/qemu_x86_64_x11_midori_defconfig

Como gerar esse arquivo de configuração:

1. Siga: Como instalar o X11 no meu próprio sistema Linux Buildroot? | Unix e Linux Stack Exchange para criar uma imagem com o X11.
2. make menuconfig
   1. Conjunto de ferramentas
      1. Biblioteca C
         1. glibc (para midori)
   2. Pacotes de destino
      1. Bibliotecas e aplicativos gráficos
         1. mesa3d
            1. selecione todos os drivers Gallium e DRI, pois não entendo qual deles é necessário (para OpenGL EGL)
            2. OpenGL EGL (para libgtk3)
      2. Bibliotecas
         1. Gráficos 1. libgtk3 (para midori)

Limpe a compilação porque alteramos a cadeia de ferramentas e compilamos novamente:

rm -rf output
make BR2_JLEVEL=$(nproc)

Espere horas. Então o de sempre:

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

E de dentro do QEMU:

root
startx

e, na GUI do X11, clique em uma xtermjanela e execute:

midori

Resultado:

Tamanho da imagem: 220M! Compare isso com os 28M de um sistema X11 vazio Como instalar o X11 no meu próprio sistema Linux Buildroot? - Unix e Linux Stack Exchange . Provavelmente por causa das dependências do WebKit + GTK3.

Testado no host Ubuntu 16.04, QEMU 2.5.0.

NetSurf

Escrito em SDL, que suporta o fbdev: http://www.netsurf-browser.org/about/screenshots/#framebuffer

O fbdev é uma interface de nível inferior oferecida por um módulo do kernel Linux que não passa pelo X11 (acho que o X11 pode opcionalmente usá-lo como back-end). Você basicamente escreve na memória e isso aparece na tela.

Para usar o fbdev no Ubuntu, você precisa estar em um TTY (por exemplo, Ctrl + Alt + F1).

Portanto, você provavelmente poderá obter uma imagem bem menor que a de Midori.

O Buildroot 2016.05 tem um pacote netsurf-buildsystemque deve fornecer, mas eu não testei. Se alguém conseguir executá-lo, edite em um link para um .config, captura de tela e tamanho da imagem.

Eu escrevi um pequeno script bash uma vez que pega um ISO do Arch Linux e gera um novo ISO com uma imagem raiz modificada que faz uma instalação totalmente automatizada. Isso inclui particionamento, além de instalar e configurar o sistema com Xorg, FVWM e Chromium. O sistema instalado fará login automaticamente e iniciará o Chromium. Basta colocar o novo ISO em uma unidade flash USB e recuar. ;-)

Isenção de responsabilidade: o script é fornecido como está, sem garantia. Eu não o uso há algum tempo, por isso pode precisar de um ajuste aqui ou ali. Modifique conforme necessário.

#!/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 um sistema como esse, eu recomendo o Puppy .

Embora você possa criar sua distro usando qualquer versão do Linux, o Puppy facilita muito a criação de imagens inicializáveis ​​personalizadas, foi projetado para ser compacto e possui excelente suporte ao sistema de arquivos de sobreposição.

Eu deveria ser capaz de dd o disco rígido

Não - eu recomendo a criação de uma imagem inicializável que você possa manter com sensibilidade - a abordagem que você sugere voltará e o morderá.

• Várias pessoas mencionaram o uzbl e eu concordo que é uma boa escolha - mas você pode achar o luakit ainda melhor.

• Como Caleb já mencionou, você realmente não precisa nenhum gerenciador de janelas. Aqui está um exemplo de script que eu criei para executar um servidor Xorg sem WM e com o 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
  

  Ele usa o xdotool para maximizar a janela logo após o início do luakit. Talvez exista uma solução melhor para isso ...

• Para a base desse sistema, eu recomendaria definitivamente o Gentoo. Isso não é apenas porque eu o conheço melhor;), mas também porque ele usa uma abordagem bastante única de gerenciar globalmente as opções de tempo de compilação de todo o software instalado. Quero dizer, o bandeiras USE . Com esses, você determina o conjunto de recursos / bibliotecas / padrões que são usados ​​por todos os programas que os suportam - por exemplo, se você deseja que seus programas usem o ALSA e não precise de recursos adicionais de áudio como esd, jack ou pulseaudio, coloque alsa -jack -esd -pulseaudioentre suas bandeiras USE. Depois disso, cada software que você cria que podeo uso de back-end de áudio adicionais além do ALSA será construído sem o suporte para eles. Como isso acontece no nível de configuração / compilação, você acaba com um software significativamente mais fino. Portanto, essa é uma filosofia de construir (respeitando todas as dependências) em vez de remover (o que pode acabar sendo de buggy e muito difícil de manter).

Vou mencionar isso porque estou surpreso que ninguém mais o fez.

Linux from Scratch é um livro (pdf) que orienta você na criação de sua própria distribuição Linux. Pode ser um exagero para o que você está tentando realizar (na verdade, é porque você já possui as ferramentas necessárias), mas pode ser uma ferramenta inestimável para entender como um sistema funciona. Realmente não é tão difícil e não há programação envolvida.