Introduzione

Questa guida descrive i passi per predisporre un chroot per costruire i pacchetti per Ubuntu tramite il programma pbuilder.

È raccomandato per gli sviluppatori o per chiunque sia interessato a costruire i pacchetti per Ubuntu e sistemi basati su apt e dpkg. Attraverso questo programma è possibile effettuare un discreto numero di operazioni con facilità tra le quali:

• compilare con comodità qualsiasi pacchetto .deb

• adattare un pacchetto disponibile in una release superiore di Ubuntu

• adattare un pacchetto non presente in Ubuntu

È comunque possibile costruire i pacchetti senza l'ausilio di pbuilder, ma occorre installare preventivamente tutte le dipendenze richieste dal pacchetto, le quali rimangono presenti sul sistema anche dopo aver terminato la procedura di creazione, occupando una notevole quantità di spazio su disco, senza giustificato motivo.

Di seguito, per indicare al programma per quale rilascio si intende costruire i pacchetti, sostituire nei comandi il termine nomerilascio col primo nome nella colonna Nome in codice della tabella di questa pagina.

Installazione

Installare il pacchetto pbuilder e le relative dipendenze.

Configurazione

L'installazione predefinita permette di abilitare solo i repository main e universe al momento della creazione del chroot.

Pertanto si consiglia di integrare i repository predefiniti coi restricted e multiverse.

• Aprire con i privilegi di amministrazione e con un editor di testo il file /usr/share/pbuilder/pbuilderrc e modificare la riga COMPONENTS="main universe" in:

  COMPONENTS="main universe restricted multiverse"

Inizializzazione di pbuilder

Inizializzare pbuilder con il comando:

sudo pbuilder create --basetgz /var/cache/pbuilder/nomerilascio.tgz --distribution nomerilascio

In questo modo verrà creato il chroot scaricando da Internet diversi pacchetti per creare un ambiente minimale ma perfettamente funzionante di Ubuntu, completamente isolato dal sistema ospitante.

Individuare nome sorgente

Per procedere alla creazione di un pacchetto occorre individuare il nome del sorgente relativo al pacchetto .deb che si intende costruire, per farlo seguire una della seguenti procedure in funzione dell'ambiente desktop del proprio sistema.

Ubuntu e derivate basate su librerie GTK

Leggere la seguente pagina.

Kubuntu e derivate basate su librerie Qt

Leggere la seguente pagina.

Creazione dei pacchetti

1. Aprire con i privilegi di amministrazione e con un editor di testo il file /etc/apt/sources.list e decommentare (togliendo il carattere # iniziale) la riga

   # deb-src http://it.archive.ubuntu.com/ubuntu/

2. Scaricare il pacchetto sorgente richiesto digitando il comando:

   sudo apt-get source nomesorgente

   • sostituendo nomesorgente col nome del sorgente desiderato.
     In alternativa scaricare i sorgenti direttamente dal sito Ubuntu.com selezionando il rilascio desiderato.

3. Una volta ottenuti i vari file che formano il pacchetto sorgente, eseguire il comando:

   sudo pbuilder build --basetgz /var/cache/pbuilder/nomeverisione.tgz --distribution nomerilascio nomepacchetto.dsc

   • sostituendo nomesorgente col nome del sorgente desiderato.

4. Inizierà il processo di creazione che comprende le seguenti fasi:

   • Creazione del chroot

   • Verifica delle dipendenze del pacchetto
   • Scaricamento delle dipendenze necessarie e loro installazione
   • Compilazione del codice sorgente
   • Creazione del pacchetto
   • Cancellazione dei file temporanei utilizzati

Se la compilazione ha avuto esito positivo, il pacchetto in formato .deb sarà disponibile nella directory /var/cache/pbuilder/result, pronto per essere utilizzato.

Creazione con pdebuild

A volte potrebbe essere necessario modificare alcuni file sorgente per applicare patch, oppure adattare uno o più file di controllo.

1. Installare gli ulteriori pacchetti devscripts, debhelper, dpatch, cdbs necessari.

2. Scaricare i sorgenti del pacchetto da compilare col seguente comando:

   sudo dpkg-source -x nomesorgente.dsc

   Sostituire nomesorgente col nome del sorgente desiderato.

3. Spostarsi nella cartella appena creata ove sono stati salvati i sorgenti.

4. Apportate le modifiche desiderate.

5. Digitare il seguente comando:

   sudo pdebuild -- --basetgz /var/cache/pbuilder/nomerilascio.tgz --distribution nomerilascio

Aggiornare la chroot

Si raccomanda di aggiornare periodicamente il chroot con le nuove versioni dei pacchetti, onde evitare problemi con le dipendenze nell'installazione dei pacchetti compilati con pbuilder.

A tal fine è sufficiente digitare il comando:

sudo pbuilder update --basetgz /var/cache/pbuilder/nomerilascio.tgz --distribution nomerilascio

sostituendo nomerilascio col nome del rilascio desiderato.

Pulizia della cache

Con il tempo la cache di pbuilder può diventare estremamente voluminosa ed è consigliabile effettuare una pulizia periodica delle directory delle dipendenze.

Per eseguire la pulizia digitare il seguente comando:

sudo pbuilder clean

Uso di pbuilder-distribution

Le opzioni di pbuilder sono potenti, ma potrebbe essere poco conveniente ripeterle ogni volta, specialmente nel caso si gestiscano più chroot contemporaneamente.
Per velocizzare il lavoro è possibile usare lo script pbuilder-distribution, crendo un collegamento a un file creato ad hoc.

Per creare il collegamento simbolico digitando il comando:

sudo ln -s /usr/share/doc/pbuilder/examples/pbuilder-distribution.sh /usr/local/bin/pbuilder-nomerilascio

Creando questo link simbolico, è possibile effettuare le operazioni sul chroot desiderato senza specificare alcun parametro opzionale (come ad esempio --distribution o --basetgz), dato che pbuilder-distribution si occupa di gestire il tutto automaticamente.

I comandi disponibili sono i medesimi di pbuilder:

   create
   update
   build
   clean
   login
   execute

Creazione pacchetti i386 con pbuilder su architetture AMD64

Una cosa molto utile di pbuilder è la possibilità di creare pacchetti per architetture a 32 bit i386 da macchine con architettura a 64 bit AMD64, tramite la creazione di un chroot i386

Per creare il chroot i386 digitare il comando:

sudo pbuilder create --debootstrapopts --arch --debootstrapopts i386

Molteplici pbuilder

Quando si lavora con i pacchetti, spesso si desidera disporre di più pbuilder sul proprio computer (per esempio se si desidera un backport per un rilascio di Ubuntu successivo a quello in uso, o mentre si lavora sulla versione di sviluppo di Ubuntu, oppure per costruire dei pacchetti per Debian ecc.).

Per agevolare la gestione di molteplici pbuilder, si consiglia di installare il pacchetto pbuilder-scripts, che fornisce diversi script wrapper che semplificano il lavoro.

Nei seguenti paragrafi si forniscono le informazioni di base per creare e usare più pbuilder.

Per approfondire è possibile consultare la documentazione allegata al programma (attraverso i file /usr/share/doc/pbuilder/pbuilder-doc.pdf e /usr/share/doc/pbuilder/pbuilder-doc.html).

Aggiornamento di debootstrap

Si raccomanda di utilizzare sempre una versione aggiornata di debootstrap del repository backports di qualsiasi rilascio di Ubuntu si sta utilizzando.

Per attivare i repository backports seguire le istruzioni presenti in questa pagina.

Cambiare la posizione del file base.tgz

Da predefinito pbuilder è configurato per gestire una singola distribuzione, cioè il rilascio di Ubuntu in cui è installato.

Per gestire più distribuzioni è sufficiente specificare locazioni diverse per ciascun archivio riferito a ogni singola distribuzione.

Invece di specificare ogni volta la locazione dell'archivio tramite l'opzione --base.tgz, si può integrare la configurazione personalizzando il file di configurazione per pbuilder.

Per personalizzare il file seguire i seguenti passaggi:

1. Aprire con i privilegi di amministrazione e con un editor di testo il file /etc/pbuilderrc.

2. Aprire con un secondo editor di testo il file /usr/share/pbuilder/pbuilderrc.

3. Copiare dal secondo editor al primo editor i blocchi di codice che si vogliono personalizzare.

4. Di seguito un esempio di blocchi di codice per configurare la gestione di più distribuzioni,. Debian e Ubuntu, e in esse più rilasci:

   # Codenames for Debian suites according to their alias. Update these when
   # needed.
   UNSTABLE_CODENAME="sid"
   TESTING_CODENAME="squeeze"
   STABLE_CODENAME="lenny"
   STABLE_BACKPORTS_SUITE="$STABLE_CODENAME-backports"
   
   # List of Debian suites.
   DEBIAN_SUITES=($UNSTABLE_CODENAME $TESTING_CODENAME $STABLE_CODENAME
       "unstable" "testing" "stable")
   
   # List of Ubuntu suites. Update these when needed.
   UBUNTU_SUITES=("nomerilascio in uso" "nomerilascio in sviluppo")
   
   # Mirrors to use. Update these to your preferred mirror.
   DEBIAN_MIRROR="ftp.us.debian.org"
   UBUNTU_MIRROR="mirrors.kernel.org"
   
   # Optionally use the changelog of a package to determine the suite to use if
   # none set.
   if [ -z "${DIST}" ] && [ -r "debian/changelog" ]; then
       DIST=$(dpkg-parsechangelog | awk '/^Distribution: / {print $2}')
       # Use the unstable suite for certain suite values.
       if $(echo "experimental UNRELEASED" | grep -q $DIST); then
           DIST="$UNSTABLE_CODENAME"
       fi
   fi
   
   # Optionally set a default distribution if none is used. Note that you can set
   # your own default (i.e. ${DIST:="unstable"}).
   : ${DIST:="$(lsb_release --short --codename)"}
   
   # Optionally change Debian release states in $DIST to their names.
   case "$DIST" in
       unstable)
           DIST="$UNSTABLE_CODENAME"
           ;;
       testing)
           DIST="$TESTING_CODENAME"
           ;;
       stable)
           DIST="$STABLE_CODENAME"
           ;;
   esac
   
   # Optionally set the architecture to the host architecture if none set. Note
   # that you can set your own default (i.e. ${ARCH:="i386"}).
   : ${ARCH:="$(dpkg --print-architecture)"}
   
   NAME="$DIST"
   if [ -n "${ARCH}" ]; then
       NAME="$NAME-$ARCH"
       DEBOOTSTRAPOPTS=("--arch" "$ARCH" "${DEBOOTSTRAPOPTS[@]}")
   fi
   BASETGZ="/var/cache/pbuilder/$NAME-base.tgz"
   # Optionally, set BASEPATH (and not BASETGZ) if using cowbuilder
   # BASEPATH="/var/cache/pbuilder/$NAME/base.cow/"
   DISTRIBUTION="$DIST"
   BUILDRESULT="/var/cache/pbuilder/$NAME/result/"
   APTCACHE="/var/cache/pbuilder/$NAME/aptcache/"
   BUILDPLACE="/var/cache/pbuilder/build/"
   
   if $(echo ${DEBIAN_SUITES[@]} | grep -q $DIST); then
       # Debian configuration
       MIRRORSITE="http://$DEBIAN_MIRROR/debian/"
       COMPONENTS="main contrib non-free"
       # This is for enabling backports for the Debian stable suite.
       if $(echo "$STABLE_CODENAME stable" | grep -q $DIST); then
           EXTRAPACKAGES="$EXTRAPACKAGES debian-backports-keyring"
           OTHERMIRROR="$OTHERMIRROR | deb http://www.backports.org/debian $STABLE_BACKPORTS_SUITE $COMPONENTS"
       fi
   elif $(echo ${UBUNTU_SUITES[@]} | grep -q $DIST); then
       # Ubuntu configuration
       MIRRORSITE="http://$UBUNTU_MIRROR/ubuntu/"
       COMPONENTS="main restricted universe multiverse"
   else
       echo "Unknown distribution: $DIST"
       exit 1
   fi
   , 

Di seguito alcuni esempi di personilizzazione per distribuzioni differenti, rilasci specifici o architetture alternative:

 # Creare un ambiente di base per Ubuntu <nomerilascio> 
 sudo DIST=<nomerilascio> pbuilder create 

 # Creare un ambiente di base per Debian sid 
 sudo DIST=sid pbuilder create

 # Creare una base per l'ambiente sotto Ubuntu <nomerilascio> AMD64 
 # per l'architettura i386 
 sudo DIST=<nomerilascio> ARCH=i386 pbuilder create 

 # Aggiornare l'ambiente per Ubuntu <nomerilascio> 
 sudo DIST=<nomerilascio> pbuilder update 

 # Crea un pacchetto utilizzando come base Ubuntu <nomerilascio>
 DIST=<nomerilascio> pdebuild 

 # Crea un pacchetto utilizzando come base  Ubuntu <nomerilascio>
 # con architettura i386
 DIST=<nomerilascio> ARCH=i386 pdebuild 

Per approfondire l'argomento sulla personalizzazione della configurazione, consultare la relativa pagina man digitando nel terminale il comando:

man pbuilderrc

Ulteriori risorse

• pbuilder Documento originale

• Sito ufficiale del progetto

• Documentazione ufficiale

---

CategoryProgrammazione