Guida verificata con Ubuntu: 20.04

Problemi in questa pagina? Segnalali in questa discussione

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:

È 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.

Questo programma richiede di avere una connessione di rete stabile e veloce. In mancanza di tali requisiti sarà necessario procedere alla costruzione manuale dei pacchetti.

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.

Alcuni utenti potrebbero avere l'esigenza di inserire anche altri repository di Ubuntu quali *-backports, *-security, *-updates, *-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

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.

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 un chroot, è possibile configurare il file /usr/share/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.

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.

La maggior parte dei pacchetti sorgenti è formato da tre file. I primi due, ovvero l'archivio dei sorgenti con estensione .orig.tar.gz, .orig.tar.bz2 o .orig.tar.xz e il file di descrizione con estensione .dsc, sono forniti per tutti. Invece il terzo, ovvero il file delle differenze con estensione .diff.gz, .debian.tar.gz, .debian.tar.bz2 o .debian.tar.xz, per una parte minore dei pacchetti non è disponibile poiché integrato nell'archivio del relativo sorgente.

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

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 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

L'architettura a 32 bit non è più mantenuta da Ubuntu a partire dal rilascio 21.04.

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.

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

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
    , 

Nel codice sono presenti alcune righe facoltative, dopo i commenti, che iniziano con "Optionally". È possibile decommentare queste linee o modificarle, a seconda delle proprie esigenze.

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


CategoryProgrammazione

Programmazione/Pbuilder (l'ultima modifica è del 29/05/2021 15.22.55, fatta da wilecoyote)