• Immutable Page
  • Info
  • Attachments


Problemi in questa pagina? Segnalali in questa discussione.

Introduzione

Questo documento descrive i passi per predisporre una chroot jail per la costruzione dei pacchetti per Ubuntu usando pbuilder. È raccomandato per gli sviluppatori o per chiunque sia interessato nella costruzione di pacchetti per Ubuntu e sistemi basati su apt. Attraverso questo strumento è possibile effettuare un discreto numero di operazioni con facilità tra le quali:

  • Compilare con comodità qualsiasi pacchetto Debian
  • 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.

Installazione

Ubuntu fornisce nativamente questi pacchetti, quindi è possibile installarli con facilità usando il gestore di pacchetti preferito.

È consigliabile usare sempre l'ultima versione di pbuilder (al momento è la 0.201). pbuilder necessita di debootstrap per poter funzionare. Anche in questo caso è consigliabile utilizzare l'ultima versione disponibile (al momento è la 1.0.35).

Configurazione

L'installazione predefinita permette di abilitare solo il repository main al momento della creazione della chroot jail.

Onde evitare problemi di dipendenze durante la procedura, è consigliabile modificare il file /etc/pbuilder/pbuilderrc adattando l'opzione COMPONENTS in questo modo:

COMPONENTS="main restricted universe multiverse"

Alcuni utenti potrebbero avere l'esigenza di inserire anche altri repository di Ubuntu quali *-backports, *-security, *-updates o *-proposed o di terze parti. Usare questa opportunità con cautela nel caso si distribuisca software per un repository pubblico o per l'upload su REVU, in quanto è possibile che non tutte le dipendenze vengano soddisfatte correttamente.

Inizializzazione di pbuilder

Ora che la fase preparatoria è terminata, è necessario inizializzare pbuilder con il comando:

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

In questo modo verrà creata la chroot jail scaricando da Internet diversi pacchetti per creare un ambiente minimale ma perfettamente funzionante di Ubuntu, completamente isolato dal sistema ospitante. Avere una connessione a banda larga è caldamente consigliato.

Le opzioni «--basetgz» e «--distribution» servono per indicare a pbuilder quale versione di Ubuntu si intende gestire. Nel caso in cui non si fosse interessati a mantenere più di una chroot jail, è possibile adattare il file /etc/pbuilder/pbuilderrc modificando la variabile «DISTRIBUTION» secondo le proprie esigenze. In questo caso le due opzioni possono essere tranquillamente omesse, anche per i comandi che verranno presentati in seguito.

Creazione dei pacchetti

Per procedere alla creazione di un pacchetto occorre dotarsi dei relativi pacchetti sorgenti, reperibili per mezzo del comando:

apt-get source

o direttamente dal sito http://packages.ubuntu.com. Solitamente ogni pacchetto sorgente è formato da tre file, l'archivio dei sorgenti con estensione .orig.tar.gz, .orig.tar.bz2 o .orig.tar.xz, il file delle differenze con estensione .diff.gz, .debian.tar.gz, .debian.tar.bz2 o .debian.tar.xz, e il file di descrizione con estensione .dsc.

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

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

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

  • Scompattazione della chroot jail
  • 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 accade che si rende necessario modificare alcuni file sorgente per applicare patch oppure adattare uno o più file di controllo. Per poter procedere alla pacchettizzazione, occorre per prima cosa ottenere i sorgenti del pacchetto da compilare con il comando:

dpkg-source -x nomepacchetto.dsc

Una volta terminata l'operazione, è necessario spostarsi nella directory dei sorgenti appena generata e, dopo aver apportato le modifiche desiderate, eseguire il comando:

pdebuild -- --basetgz /var/cache/pbuilder/oneiric.tgz --distribution oneiric

In questo caso è però necessario installare i seguenti pacchetti aggiuntivi:

  • devscripts

  • debhelper

  • dpatch

  • cdbs

Aggiornare la chroot jail

Ogni tanto è consigliabile aggiornare la chroot jail con le nuove versioni dei pacchetti onde evitare problemi con le dipendenze nell'installazione dei pacchetti compilati con pbuilder. Per poter fare ciò è sufficiente eseguire il comando:

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

Pulizia della cache

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

sudo pbuilder clean

Il comando non andrà a cancellare i pacchetti creati e riposti in /var/cache/pbuilder/result.

Uso di pbuilder-distribution

Le opzioni di pbuilder sono potenti, ma a volte è noioso ripeterle ogni volta. Questo è particolarmente vero nel caso si gestiscano più chroot jail contemporaneamente.

Per velocizzare il lavoro è possibile utilizzare lo script pbuilder-distribution in questo modo:

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

Creando questo link simbolico, è possibile effettuare le operazioni sulla chroot jail desiderata senza specificare alcun parametro opzionale quali --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 i386 da macchine con architettura AMD64. Questo è possibile creando una chroot i386 con il comando:

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

Se siete interessati alla compilazione per varie architetture e distribuzioni vi consiglio la lettura del paragrafo successivo.

pbuilder multipli

Quando si lavora con i pacchetti, spesso si desidera disporre di più pbuilders sul tuo computer, per esempio se si desidera un backport per Natty, mentre si lavora sulla versione di sviluppo di Ubuntu. Oppure si vuole costruire i pacchetti per Debian. Le prossime sezioni forniscono alcune informazioni per iniziare con l'utilizzo di più pbuilders.

Aggiornamento di debootstrap

Si raccomanda di utilizzare sempre una versione aggiornata di debootstrap del repository backports di qualsiasi versione di Ubuntu si sta utilizzando. È possibile attivare i backports nel vostro sources.list attraverso la configurazione del file. Aggiornando la versione si avrà maggior supporto per le distribuzioni più recenti, come il ramo di sviluppo di Ubuntu.

Cambiare la posizione del file base.tgz

L'unica cosa necessaria per utilizzare pbuilder con diverse distribuzioni è un percorso alternativo per memorizzare l'archivio che contiene l'ambiente. Sulla riga di comando, questo può essere specificato con l'opzione 'basetgz'. Tuttavia, è noioso specificare il percorso completo ogni volta che viene eseguito pbuilder, quindi è conveniente creare un frammento di codice in ~/.Pbuilderrc per automatizzare il tutto:

# 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=("natty" "oneiric")

# 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

Ci sono alcune linee facoltative in questo frammento di codice che compaiono dopo i commenti che iniziano con "Optionally". È possibile decommentare queste linee o cambiarle per soddisfare le proprie esigenze.

Ora, se l'utente utilizza un'ltra DIST distribuzione, la posizione del tarball sarà cambiata. La linea che definisce la distribuzione ha effetto solo durante la creazione di un nuovo archivio di base, o se il - override-config è impostato diversamente. L'impostazione di BUILDRESULT o APTCACHE è facoltativa, ma potrebbe tornare utile. Se ARCH è impostato su una diversa architettura rispetto a quella della macchina si creerà un ambiente per compilare i pacchetti per quell'architettura. Siamo ora in grado di creare ed utilizzare l'alternativo tarball, come nei seguenti esempi:

 # Creare un ambiente di base per Ubuntu Natty 
 sudo DIST=natty pbuilder create 

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

 # Creare una base per l'ambiente sotto Ubuntu Natty AMD64 
 # per l'architettura i386 
 sudo DIST=natty ARCH=i386 pbuilder create 

 # Aggiornare l'ambiente per Ubuntu Natty 
 sudo DIST=natty pbuilder update 

 # Crea un pacchetto utilizzando come base Ubuntu Natty
 DIST=natty pdebuild 

 # Crea un pacchetto utilizzando come base  Ubuntu Natty
 # con architettura i386 
 DIST=natty ARCH=i386 pdebuild 

Ulteriori risorse


CategoryDaRevisionare CategoryProgrammazione