Wiki Ubuntu-it

Indice
Partecipa
FAQ
Wiki Blog
------------------
Ubuntu-it.org
Forum
Chiedi
Chat
Cerca
Planet
  • Pagina non alterabile
  • Informazioni
  • Allegati

Versione 3 del 10/06/2006 08.43.06

Nascondi questo messaggio

Realizzare un Chroot con Debootstrap

Una breve guida su come realizzare una root alternativa

Introduzione

Questo tutorial mostra come usare debootstrap per realizzare un ambiente chroot che può essere usato per diversi usi: provare le ultime release di Ubuntu, testare nuovi programmi senza "sporcare" il proprio sistema, avere un sistema a 32-bit secondario (per utilizzare programmi disponibili solo a 32-bit, senza dover rinunciare ad un sistema a 64-bit) o anche lavorare con Debian... tutto è possibile con un chroot.

Prima si installeranno gli strumenti per ottenere un chroot e si spiegherà come realizzare una configurazione di base, dopo si descriverà come accedere al login del sistema di chroot da un diverso terminale virtuale (quelli ottenibili premendo CTRL+ALT ed F1, F2, etc), poi come consentire ad un utente normale di accedere al chroot mantenendo le sue varibili d'ambiente ed infine come accedere ai programmi residenti nel chroot direttamente dal vostro sistema.

Quello che leggerete non è un'opera originale (il grazie va agli autori dei riferimenti riportati) ma solo una libera interpretazione dei loro accorgimenti adattati alle mie esigenze.

Definizioni e notazioni

Tutto è stato provato su una Ubuntu Breezy Badger, ma non c'è motivo di ritenere che non funzioni su una Ubuntu DapperDrake o su una Debian. Si immagina che abbiate una connessione alla rete disponibile.

Si indicherà con @main il sistema principale e con @chroot la shell nel sistema chroot. Con user@ e root@ si indicano un utente comune e l'amministratore, rispettivamente. Per risparmiare la scrittura di molti sudo, da una shell invocate i diritti di root:

user@main$ sudo bash

Ora avete i permessi di amministrazione del sistema.

3 Creare il chroot

Utilizziamo apt-get per installare dchroot (questo pacchetto contiene un setuid binario che permette agli utenti di eseguire una shell o altri comandi sotto un differente filesystem di root) e deboostrap (che permette di creare un sistema base da scratch, senza avere apt e dpkg disponibili):

root@main# apt-get install dchroot debootstrap

Realizziamo la directory:

root@main# mkdir /mychroot

Se avete intenzione di installare diversi chroot valutate la possibilità di non utilizzzare la directory /mychroot direttamente, ma di utilizzare una sua sotto-directory (per esempio: /mychroot/primo e /mychroot/secondo, etc).

NOTA Utilizzare una partizione dedicata per il chroot rende tutto molto più elegante, anche se non indispensabile. Scegliete una partizione e montatela aggiungendo la riga al vostro file /etc/fstab.

Modifichiamo il file /etc/dchroot.conf:

root@main# echo "il_mio_chroot /mychroot" >> /etc/dchroot.conf

Infatti, dchroot legge le configurazioni di questo file per determinare i chroot validi nel sistema. Le linee consistono di un identificatore e di un percorso separato da spazi. Se più di una linea sono presenti la prima indica il chroot di default.

Se volete un chroot a 32-bit su un sistema amd64 (o emt64) aggiungete al comando debootstrap l'opzione --arch i386, mentre userete --arch amd64 per creare un chroot a 64-bit (ma solo se avete un 64-bit!), se volete usare il chroot per costruire nuovi pacchetti aggiungete l'opzione --variant=buildd.

Per realizzare un chroot a 32-bit di breezy:

root@main# debootstrap --arch i386 breezy /mychroot/ http://archive.ubuntu.com/ubuntu

Sostituite breezy con dapper se volete DapperDrake. Ovvero scriverete:

root@main# debootstrap --arch i386 dapper /mychroot/ http://archive.ubuntu.com/ubuntu

Alternative per realizzare un chroot di Debian:

root@main# debootstrap --arch i386 sid /mychroot/ http://ftp.debian.org/debian/
root@main# debootstrap --arch amd64 sid /mychroot/ http://amd64.debian.net/debian-amd64/

NOTA Alcuni autori consigliano di eseguire il chroot di una debian testing e solo dopo di aggiornare a sid.

Se debootstrap termina con successo avete un sistema base in /mychroot, ma occorrono alcune operazioni per renderlo utilizzabile con successo. Montate il filesystem /proc per il chroot:

root@main# echo "/proc /mychroot/proc proc defaults 0 0" >> /etc/fstab
root@main# mount /proc

Copiate la configurazione del file di hosts e il file delle repository:

root@main# cp /etc/hosts /mychroot/etc/
root@main# cp /etc/apt/sources.list /mychroot/etc/apt/

NOTA Modificate il file sources.list se necessario, affinche apt-get punti alle corrette repository.

Finalmente entrate nel vostro nuovo chroot:

root@main# chroot /mychroot/

Aggiornate il vostro sistema (notate che nel vostro chroot siete amministratori e non è necessario utilizzare il comando sudo):

root@chroot# apt-get update
root@chroot# apt-get upgrade

Se volete riconfigurate la vostra lingua:

root@chroot# apt-get install locales dialog
root@chroot# dpkg-reconfigure locales

NOTA Diversi warning relativi a perl compariranno mentre lanciate il comando (perchè?) ma questo non pregiudica il funzionamento del chroot.

Per configurare l'ora:

root@chroot# tzconfig

Per terminare la vostra sessione nel nuovo chroot è sufficiente uscire con il comando:

root@main# exit

Se volete accedere al vostro chroot solo da amministratore potete non proseguire la lettura ed accedere al vostro chroot con il comando:

user@main$ sudo chroot /chroot/

ma probabilmente sarete in grado di utilizzare solo la shell. Se invece volete sfruttare tutta la potenza che dchroot offre (ovvero usare programmi con interfaccia grafica, ed altro) vi conviene stringere i denti e proseguire.

Configurare il login di un chroot

Come visto configurare il chroot è semplice, accedervi è ancora più semplice, ma cosi facendo nel chroot siete sempre amministratori e inoltre mantenete i set dell'ambiente principale anche nel chroot. Immaginate di poter accedere nel chroot attraverso il login di un altro terminale virtuale oppure attraverso gdm: ecco potete fare anche questo!

NOTA Se il vostro intento è solo quello di utilizzare programmi con interfaccia del chroot dal sistema principale saltate al capitolo sucessivo.

Create un nuovo utente per il sistema chroot, che vi servirà per accedervi al login:

root@chroot# adduser utente_comune_chroot

Ora, per poter dedicare un terminale virtuale al vostro chroot modificate il vostro /etc/inittab:

root@main# echo "8:23:respawn:/usr/sbin/chroot /mychroot /sbin/getty 38400 tty8"  >> /etc/inittab

Riavviate init:

root@main# init q

Premendo contemporaneamente CTRL+ALT F8 passerete nel terminale virtuale 8 dove potrete effettuare il login al vostro chroot: in questo terminale non avete X-window. Premete CTRL+ALT F7 per tornare nel terminale virtuale 7 utilizzato come default.

Se volete utilizzare X-window e Gnome (ma potrebbe essere anche KDE) nel vostro chroot, configurate i device, installate gnome, gdm e il sistema x-window:

root@chroot# cd /dev
root@chroot# /sbin/MAKEDEV generic
root@chroot# apt-get install gdm gnome x-window-system

Uscite dal chroot e modificate il file /mychroot/etc/gdm/gdm.conf, sostituendo nella sezione [servers] la riga:

0=Standard vt7

con:

1=Standard vt9

Cosi facedo avete abilitato il display :1 nel terminale virtuale 9. Prima di potervi accedere dovete configurare X modificando il file /etc/X11/xorg.conf.

NOTA Se invece di gdm volete utilizzare kdm, riferitevi alla sua documentazione per la corretta configurazione.

Da un terminale del vostro sistema:

root@main# cp /etc/X11/xorg.conf /mychroot/etc/X11/

Finalmente dal chroot potete avviare l'interfaccia grafica del chroot:

root@chroot# /etc/init.d/gdm start

Il sistema passerà automaticamente al terminale virtuale 9 dove vedrete caricare il login manager. Accedete come di consueto, utilizzando l'utente precedentemente creato. Utilizzate CTRL+ALT F7 e CTRL+ALT F9 per passare da un sistema all'altro.

Configurare un ambiente chroot per un utente comune

L'approccio precedente consente di utilizzare tutto il sistema grafico di chroot, con variabili d'ambiente diverse, anzi con un utente appositamente creato per il sistema chroot. Spesso però è necessario voler consentire all'utente comune del sistema principale di accedere ai programmi residenti nel sistema chroot, lasciandogli mantenere le proprie impostazioni di base, condividendo la /home tra sistema principale e chroot.

Copiate le informazioni degli utenti (/etc/passwd), le password criptate degli utenti (/etc/shadow), le informazioni dei gruppi (/etc/group), le abilitazioni concesse per sudo (/etc/sudoers) e le informazioni per la connessione di rete (/etc/hosts):

root@main# cp /etc/passwd /mychroot/etc/
root@main# cp /etc/shadow /mychroot/etc/
root@main# cp /etc/group /mychroot/etc/
root@main# cp /etc/sudoers /mychroot/etc/

NOTA Non è possibile realizzare un link simbolico in /mychroot/etc/ ai file originali, poichè una volta nel chroot la directory di root cambia e il link simbolico punterebbe riferendosi alle nuove condizioni.

Modificate il file /etc/fstab del vostro sistema (non del chroot) per permettere il mount di alcune directory direttamente nel chroot:

root@main# echo "/home /mychroot/home none bind 0 0" >> /etc/fstab
root@main# echo "/tmp /mychroot/tmp none bind 0 0" >> /etc/fstab
root@main# echo "/dev /mychroot/dev none bind 0 0" >> /etc/fstab
root@main# echo "/media/cdrom0 /mychroot/media/cdrom0 none bind 0 0" >> /etc/fstab
root@main# echo "/usr/share/fonts /mychroot/usr/share/fonts none bind 0 0" >> /etc/fstab

Per montare altre directory direttamente nel chroot, avrete capito che dovete aggiungere una riga nel file /etc/fstab scritta cosi: directory /mychroot/punto_di_mount none bind 0 0

Create le directory nel chroot:

root@main# mkdir /mychroot/media/cdrom0
root@main# mkdir /mychroot/usr/share/fonts

Rimontate il vostro file fstab:

root@main# mount -a

NOTA (solo per chi a letto il quarto capitolo) È probabile (anzi certo) che l'utente appositamente creato precedentemente non riesca più ad accedere al login. I due approcci hanno finalità diverse ma possono convivere: è necessario ricreare l'utente del sistema chroot, di nuovo.

Ora anche il vostro utente comune può accedere al vostro chroot ed operare in esso preservando il suo ambiente:

user@main$ dchroot -d

Ora sarà possibile lanciare ed utilizzare programmi con interfaccia grafica (preventivamente installati nel chroot). Per migliorarne l'aspetto installate gtk2-engines-ubuntulooks. Per uscire dal chroot usate il comando:

user@chroot$ exit

NOTA se avete più di un chroot e non volete utilizzare il chroot di default utilizzate il comando: user@main$ dchroot -c nome_chroot_inserito_in_dchroot.conf -d

Usare il chroot dal sistema principale

Se avete eseguito correttamente le istruzioni precedenti avete configurato un chroot nel vostro sistema e abilitato l'utilizzo del vostro chroot per gli utenti comuni. Siete in grado di lavorare con un sistema diverso e di utilizzare programmi con interfaccia grafica. Ma che noia dover lanciare i programmi da shell! (speriamo che Steve Bourne non legga il tutorial. Perdonami Steve!) Volete lanciare le vostre GUI direttamente dal vostro sitema utilizzando solo il mouse? Sciogliete le dita e... tra breve... sarete in grado di farlo.

Dopo aver installato il programma nel chroot, è necessario creare uno script nel sistema, creare un link simbolico nel sistema e un collegamento grafico da cliccare con il mouse. Per evitare omonimie tra programmi residenti nel sistema e quelli nel chroot è bene creare un link anche nel chroot (aggiungendo un opportuno suffisso).

Installate il programma nel chroot e create il link anti-omonimia:

user@chroot$ sudo apt-get install programma
user@chroot$ sudo ln -s /usr/bin/programma /usr/local/bin/programma_con_suffisso

Nel sistema principale create lo script /usr/local/bin/do_dchroot:

root@main# gedit /usr/local/bin/do_dchroot

i cui comandi saranno:

Codice:

#!/bin/bash
for arg; do
        arg=`echo $arg | sed -e 's/ /\\\ /g'`
        args=`echo $args $arg`
done
/usr/bin/dchroot -d "`echo $0 | sed 's|^.*/||'` \"$args\""

Salvate e rendete il file eseguibile:

root@main# chmod 755 /usr/local/bin/do_dchroot

Per ogni programma di chroot che volete eseguire è necessario create un link simbolico allo script do_chroot in /usr/local/bin. Se volete eseguire il programma_con_suffisso:

root@main# ln -s /usr/local/bin/do_dchroot /usr/local/bin/programma_con suffisso

Ora da una shell lanciate il comando /usr/local/bin/programma_con_suffisso (preceduto da sudo se necessario).

Se volete una icona da cliccare create un collegamento (nel desktop o in un pannello) con gnome nel quale il comando dell'applicazione sarà /usr/local/bin/programma_con_suffisso. Se volete un icona nel menu create un file programma_con_suffisso.desktop in /usr/local/share/applications.

Tutto chiaro? Probabilmente no! Facciamo un esempio: supponete di voler installare firefox nel vostro chroot. Entrate nel chroot:

user@main$ dchroot -d

Installate firefox (con tutte le sue dipendenze):

user@chroot$ sudo apt-get install firefox

Create un link simbolico a firefox nel chroot (uso il suffisso 32, perchè il mio chroot è una architettura i386 in un sistema amd64):

user@chroot$  sudo ln -s /usr/bin/firefox /usr/local/bin/firefox32

Uscite dal chroot:

user@chroot$  exit

Create un link nel vostro sistema:

user@main$ sudo ln -s /usr/local/bin/do_dchroot /usr/local/bin/firefox32

Ora da shell chiamate il comando firefox32, oppure se avete creato il collegamento grafico... cliccateci sopra: il firefox a 32-bit dovrebbe essere pronto per voi.

NOTA Se installate synaptic nel vostro chroot, dal vostro sistema principale lo invocherete con sudo synaptic32. Se ne volete fare un collegamento grafico userete il comando gksudo /usr/sbin/synaptic.

Nota Un altro modo più veloce di invocare un programma nel chroot è:

user@main$ dchroot -d nomeprogramma

Conclusioni

Questo breve tutorial vi consente di installare un chroot nel vostro sistema principale. Potete usare il chroot da riga di comando da root o da utente normale, potete accedere al vostro chroot da riga di comando oppure graficamente con variabili d'ambiente diverse, potete utilizzare i programmi residenti nel chroot dal vostro sistema principale... potete fare quello che volete, come sempre. Liberamente.

Montare un cdrom dentro il chroot

Modificare il file fstab dentro al chroot aggiungendo la riga del device del cdrom.

Per esempio: il mio cdrom è indicato come /dev/hda, aggiungerò la riga:

/dev/hda /media/cdrom0 udf,iso9660 user,noauto 0 0

Per l'uso del cdrom è necessaria la riga di comando:

mount /media/cdrom0, per montare
umount /media/cdrom0, per smontare

La procedura senza commenti

Di seguito l'elenco dei comandi (senza commenti) da invocare per realizzare un chroot 32-bit di breezy in un sistema breezy a 64-bit. Il chroot è instalato in /mychroot/breezy32. Al termine si installerà synaptic per il sitema a 32-bit.

Codice:

sudo bash
>>inserire vostra password
apt-get install dchroot debootstrap
mkdir /mychroot
mkdir /mychroot/breezy32
echo "breezy32 /mychroot/breezy32" >> /etc/dchroot.conf
debootstrap --arch i386 breezy /mychroot/breezy32/ http://archive.ubuntu.com/ubuntu
echo "/proc /mychroot/breezy32/proc proc defaults 0 0" >> /etc/fstab
mount /proc
cp /etc/hosts /mychroot/breezy32/etc/
cp /etc/apt/sources.list /mychroot/breezy32/etc/apt/
chroot /mychroot/breezy32/

apt-get update
apt-get upgrade
apt-get install locales dialog
dpkg-reconfigure locales
tzconfig
cd /dev
/sbin/MAKEDEV generic
apt-get install gdm gnome x-window-system
exit

gedit /mychroot/breezy32/etc/gdm/gdm.conf
>>Sostituire nella sezione [servers] 0=Standard vt7 con 1=Standard vt9
>>Salvare

echo "8:23:respawn:/usr/sbin/chroot /mychroot/breezy32 /sbin/getty 38400 tty8"  >> /etc/inittab
init q
cp /etc/X11/xorg.conf /mychroot/breezy32/etc/X11/
cp /etc/passwd /mychroot/breezy32/etc/
cp /etc/shadow /mychroot/breezy32/etc/
cp /etc/group /mychroot/breezy32/etc/
cp /etc/sudoers /mychroot/breezy32/etc/
echo "/home /mychroot/breezy32/home none bind 0 0" >> /etc/fstab
echo "/tmp /mychroot/breezy32/tmp none bind 0 0" >> /etc/fstab
echo "/dev /mychroot/breezy32/dev none bind 0 0" >> /etc/fstab
echo "/media/cdrom0 /mychroot/breezy32/media/cdrom0 none bind 0 0" >> /etc/fstab
echo "/usr/share/fonts /mychroot/breezy32/usr/share/fonts none bind 0 0" >> /etc/fstab
mkdir /mychroot/breezy32/media/cdrom0
mkdir /mychroot/breezy32/usr/share/fonts
mount -a
chroot /mychroot/breezy32/

adduser user32
>>rispondere alle domande
apt-get install synaptic
ln -s /usr/bin/synaptic /usr/local/bin/synaptic32
exit

gedit /usr/local/bin/do_dchroot
>>Scrivere
  #!/bin/bash
  for arg; do
          arg=`echo $arg | sed -e 's/ /\\\ /g'`
          args=`echo $args $arg`
  done
  /usr/bin/dchroot -d "`echo $0 | sed 's|^.*/||'` \"$args\""
>>Salvare
chmod 755 /usr/local/bin/do_dchroot
ln -s /usr/local/bin/do_dchroot /usr/local/bin/synaptic32

Per avviare synaptic per il 32-bit dal sistema 64-bit:

sudo synaptic32
>> inserire password

Per avviare il secondo display (quando necessario):

sudo dchroot -d
>>inserire password
sudo /etc/init.d/gdm start
>> inserire password

Riferimenti

The Debian GNU/Linux AMD64 HOW-TO - 2005 - Rosenberg, Iverson, von Brederlow, Schueler, Mills, Pariset - http://alioth.debian.org/docman/view.php/30192/21/debian-amd64-howto.html

Debian Reference Chapter 8 Debian tips - 2006 -Aoki et al. - http://qref.sourceforge.net/Debian/reference/reference.en.html

Nota: "La guida Debian" è tradotta in italiano - http://qref.sourceforge.net/Debian/reference/reference.it.html

DebootstrapChroot - Marzo 2006 - Autori vari - https://wiki.ubuntu.com/DebootstrapChroot

HOWTO: 32-Bit Chroot on 64-Bit Installs - Aprile 2005 - Autori vari - http://www.ubuntuforums.org/showthread.php?t=24575

Pagine di man - Autori vari - Nel vostro sistema invocando il comando man nome_programma

L'autore

Giugno 2006 - UgodiPerso - ugodiperso@virgilio.it


CategoryNuoviDocumenti CategoryNuoviDocumenti