Pbuilder: compilazione in ambienti puliti

Versioni Compatibili Tutte le versioni supportate di Debian

Introduzione

Pbuilder è uno strumento che permette di creare un ambiente pulito per la compilazione e il test esclusivamente dei pacchetti Debian. Inoltre può essere usato anche per effettuare i backport, compilazioni per diverse architetture (utilizzando "debootstrap" sono supportate solo "i386" e "amd64"), compilazioni particolari e tutto quello che può richiedere l'uso di un ambiente pulito e controllato.
Il principale vantaggio di utilizzare Pbuilder consiste nel fatto che tutte le librerie necessarie alla compilazione verranno scaricate (di default in /var/cache/pbuilder/aptcache) all'occorrenza dal mirror predefinito e utilizzate nell'ambiente chroot creato; il tutto senza 'sporcare' il proprio sistema.

La compilazione può essere eseguita in due modi:

• Utilizzare il comando "pdebuild" per compilare un pacchetto Debian e creare il file .deb dopo averne modificato i sorgenti (ad esempio nel caso in cui si voglia applicare una patch con quilt).
• Utilizzare il comando "pbuilder build nomefile.dsc" per compilare un pacchetto Debian non modificato, utile per evitare i bug di tipo FTBFS per una determinata release. Questo comando richiama automaticamente "pdebuild" e, quindi, è equivalente a utilizzare "pdebuild" nella directory dei sorgenti del pacchetto.

Installazione

Pbuilder è, ovviamente, contenuto in Debian:

# apt-get install pbuilder

Configurazione e opzioni

Il comando pbuilder va eseguito con i privilegi di root e normalmente non sono necessarie configurazioni particolari. Esistono opzioni che possono trovarsi nel file di configurazione /etc/pbuilder/pbuilderrc oppure nel file .pbuilderrc . Se le opzioni non dovessero essere specificate nei file, devono essere specificate insieme al comando pbuilder; se anche da linea di comando non vengono inserite, assumeranno dei valori di default.

Opzioni da file di configurazione

Queste vanno inserite nel file /etc/pbuilder/pbuilderrc (per tutti gli utenti) oppure nel file .pbuilderrc creato nella home dell'utente che esegue pbuilder . Leggere a tal proposito anche la manpage di pbuilderrc . Le opzioni specificate in questi file vengono bypassate dalle corrispondenti opzioni specificate dalla linea di comando.
Tutte queste opzioni, una per riga, sono nella forma:

OPZIONE=valore

BASETGZ

specifica il percorso e il nome del file .tgz da utilizzare. Questa opzione viene bypassata da "--basetgz"

BUILDRESULT

il percorso assoluto della directory in cui si troveranno i pacchetti .deb al termine della compilazione. Questa opzione viene bypassata da "--buildresult"

Opzioni da linea di comando

Osserviamo le opzioni più importanti:

pbuilder

--basetgz [base.tgz]

permette di indicare una locazione, per il tarball dell'ambiente da gestire, diverso da quello di default;

--buildplace [location of build]

permette di specificare una directory, diversa da quella di default, dove ricreare l'ambiente ed eseguire le compilazioni;

--mirror [mirror location]

permette di specificare un mirror Debian diverso da quello predefinito;

--othermirror [other mirror location in apt deb-line format, delimited with | signs]

permette di aggiungere altri mirror (o repository);

--http-proxy [proxy]

se è presente un proxy http nella rete, è possibile gestirne l'accesso (nella forma http://username:password@server);

--distribution [distribution(potato|woody|sarge|sid|etch|experimental)]

imposta la distribuzione;

--buildresult [location-to-copy-build-result]

permette di specificare una directory diversa in cui posizionare i pacchetti creati. Di default il risultato della compilazione sarà in "/var/cache/pbuilder/result";

--aptcache [location of retrieved package files]

permette di specificare una directory in cui immagazzinare i pacchetti Debian scaricati (e usati) per soddisfare le dipendenze per la compilazione;

--configfile [configuration file to load]

specifica un file di configurazione alternativo;

--debemail [mail address]

imposta l'indirizzo email;

--debbuildopts [dpkg-buildpackage options]

permette di impostare delle opzioni aggiuntive per il comando dpkg-buildpackage, che si occupa della creazione di un pacchetto Debian a partire dai sorgenti;

--logfile [filename to output log]

specifica un file di log, utile per analizzare con calma i risultati delle compilazioni;

--binary-arch

permette di impostare l'architettura da usare per la creazione dell'ambiente (utile nel caso di supporto per più architetture (macchina a 64 bit);

--save-after-login/--save-after-exec

permette di salvare lo stato della macchina al termine di una sessione interattiva, ricreando il tarball a partire dall'ambiente modificato (usare con attenzione).

pdebuild

--use-pdebuild-internal

--auto-debsign

impone la firma automatica al termine della compilazione del pacchetto;

--debsign-k [keyid]

imposta la chiave con cui eseguire la firma del pacchetto.

Azioni

create

creazione di un nuovo ambiente. Di default, a meno che non venga utilizzata l'opzione "--basetgz", viene creato il file /var/cache/pbuilder/base.tgz .
Con:

# pbuilder create

verrà creato il file /var/cache/pbuilder/base.tgz , mentre con:

# pbuilder create --basetgz /home/utente/pbuilder/immagine.tgz

verrà creato il file /home/utente/pbuilder/immagine.tgz .

update

aggiornamento di un ambiente esistente. Valgono le stesse considerazioni espresse per la creazione. Di default, a meno che non venga utilizzata l'opzione "--basetgz", viene aggiornato il file /var/cache/pbuilder/base.tgz .
Con:

# pbuilder update

verrà aggiornato il file /var/cache/pbuilder/base.tgz , mentre con:

# pbuilder update --basetgz /home/utente/pbuilder/immagine.tgz

verrà aggiornato il file /home/utente/pbuilder/immagine.tgz .
Ricordarsi di utilizzare sempre questo comando prima di ogni nuova operazione con pbuilder.

build

compilazione.

clean

pulizia di un ambiente. Viene cancellata sia la directory /var/cache/pbuilder/build/ utilizzata per la compilazione, sia tutti i pacchetti .deb precedentemente scaricati che si trovano nella directory /var/cache/pbuilder/aptcache/ :

# pbuilder clean

login

login all'interno di un ambiente.
Il login permette di accedere all'ambiente creato e poi di installare pacchetti o modificare file.
Con:

# pbuilder login

si accederà all'ambiente individuato dal file /var/cache/pbuilder/base.tgz , mentre con:

# pbuilder login --basetgz /home/utente/pbuilder/immagine.tgz

si accederà all'ambiente associato al file /home/utente/pbuilder/immagine.tgz .
Utilizzare l'opzione "--save-after-login" per rendere disponibili i cambiamenti effettuati anche al successivo login; senza questa opzione tutti i cambiamenti non saranno salvati.
Il classico "exit" permette il logout.

execute

esecuzione di un comando all'interno di un ambiente.

dumpconfig

mostra a video la configurazione dell'ambiente specificato, utile per le operazioni di debug.

Utilizzo

Creazione dell'ambiente

In questo esempio creeremo un ambiente per la distribuzione Sid, con i repository Debian main, contrib e non-free.

# pbuilder create --basetgz /home/maxer/pbuilder/sid.tgz --mirror http://debian.fastweb.it/debian --othermirror http://debian.fastweb.it/debian contrib non-free --distribution sid --debemail maxer@knio.it --binary-arch i386

Analizzando il comando osserviamo che:

• con --basetgz impostiamo un percorso esistente ma diverso per salvare il tarball che conterrà l'immagine del nostro ambiente.
• con --mirror specifichiamo un mirror italiano, mentre con --othermirror aggiungiamo anche non-free e contrib (allo stesso modo potremmo aggiungere altri repository);
• con --distribution impostiamo la distribuzione di cui vogliamo creare l'ambiente;
• con --debemail impostiamo la nostra email;
• con --bynary-arch impostiamo l'architettura dei nostri binari (utile nei sistemi a 64 bit, in cui è possibile emulare l'architettura a 32 bit ;-).

Pbuilder preleverà dalla rete il sistema base di Debian, configurerà i pacchetti scaricati e creerà il file .tgz. L'operazione richiede qualche minuto.

Aggiornamento dell'ambiente

L'aggiornamento di un ambiente è altamente consigliato (così come si farebbe per una qualunque installazione di Debian), in particolare per le release testing e unstable nelle quali sono spesso presenti degli aggiornamenti che potrebbero portare ad una modifica delle dipendenze.

Per aggiornare i pacchetti ed il database dei repository, è sufficiente un:

# pbuilder update --basetgz /home/maxer/pbuilder/sid.tgz

Compilazione di pacchetti

La compilazione può avvenire in due modi:

• da un pacchetto di sorgenti, tramite pbuilder o pdebuild
• dalla directory che contiene i sorgenti tramite pdebuild

Da un pacchetto di sorgenti

Questa procedura funziona se si dispone di un pacchetto Debian in formato sorgente; la procedura è usabile, ad esempio, per ricompilare un pacchetto presente in testing o unstable per una distribuzione stable (tecnica chiamata backport).

# pbuilder build --basetgz /home/maxer/pbuilder/sid.tgz file_0.0-1.dsc 

Questo comando avvierà la compilazione, esattamente secondo le seguenti fasi:

1. creazione dell'ambiente a partire dal tarball indicato (di default viene creata una sottodirectory in /var/cache/pbuilder/build/)
2. risoluzione delle dipendenze per la compilazione
3. download e configurazione dei pacchetti richiesti per la compilazione (di default i pacchetti sono scaricati in /var/cache/pbuilder/aptcache/)
4. compilazione
5. rimozione ambiente creato (definito sporco)
6. eventuale firma GnuPG

Il pacchetto .deb risultante dalla compilazione si troverà nella directory "/var/cache/pbuilder/result" a meno che non si sia usata l'opzione "--buildresult".

Dalla directory dei sorgenti

Questa procedura, a differenza di quella illustrata precedentemente, è molto più usata (almeno nel mio caso) in quanto può essere applicata direttamente alla directory dei sorgenti (si sta sempre parlando di pacchetti Debian, quindi i sorgenti devono contenere la directory debian/, che gestisce la creazione dei pacchetti).

Una volta posizionati nella directory contenente i sorgenti, è sufficiente eseguire questo comando:

# pdebuild -- --basetgz /home/maxer/pbuilder/sid.tgz

In questo caso, invece, la procedura seguita da pbuilder sarà leggermente diversa:

1. esecuzione debian/rules clean all'interno della directory dei sorgenti
2. creazione dell'ambiente a partire dal tarball indicato
3. risoluzione delle dipendenze per la compilazione
4. compilazione
5. rimozione ambiente creato (definito sporco)
6. eventuale firma GnuPG

Il pacchetto .deb risultante dalla compilazione si troverà nella directory "/var/cache/pbuilder/result" a meno che non si sia usata l'opzione "--buildresult". Quest'ultima va indicata prima di "--", ad esempio:

# pdebuild --buildresult /tmp -- --basetgz /home/maxer/pbuilder/sid.tgz

per creare il pacchetto .deb nella directory /tmp .

Firma GnuPG

Pbuilder permette anche la firma con chiave GnuPG, molto utile in quanto evita l'utilizzo di deb-sign, automatizzando il tutto!
L'unico problema (se così si può definire) è la necessità di esportare la propria chiave privata ed importarla nel keyring dell'utente root.

File di configurazione

Una pratica diffusa e molto comoda per semplificare l'utilizzo di pbuider sono i file di configurazione: essi permettono, infatti, di specificare direttamente al loro interno i parametri (oltre ad offrirne molti di più).

Un altro vantaggio, inoltre, consiste nel poter specificare altre distribuzioni (come Ubuntu, Knoppix, ecc) che altrimenti non sarebbero supportate dal pbuilder disponibile in Debian.

Varie

Semplifichiamo i comandi con alias

I comandi da impartire sono spesso complessi e lunghi: in questo caso ci viene in aiuta alias, che permette di creare un nuovo comando, alias di uno più complesso.

Per fare questo, è sufficiente inserire nel file /root/.bashrc delle righe simili alle seguenti:

# comandi per la compilazione
alias pdebuild-sarge="pdebuild --auto-debsign --debsign-k 34337C08 --buildresult /var/cache/pbuilder/result/stable -- --basetgz /store3/sarge.tgz --mirror http://debian.fastweb.it/debian"
alias pdebuild-etch="pdebuild --auto-debsign --debsign-k 34337C08 --buildresult /var/cache/pbuilder/result/testing -- --basetgz /store3/etch.tgz --mirror http://debian.fastweb.it/debian"
alias pdebuild-sid="pdebuild --auto-debsign --debsign-k 34337C08 --buildresult /var/cache/pbuilder/result/unstable -- --basetgz /store3/sid.tgz --mirror http://debian.fastweb.it/debian"
alias pdebuild-breezy="pdebuild --auto-debsign --debsign-k 34337C08 --buildresult /var/cache/pbuilder/result/breezy -- --basetgz /store3/breezy.tgz --configfile /root/pbuilder-breezy.conf"

# automatizziamo al massimo

alias pdebuild-all="pdebuild-sarge; pdebuild-etch; pdebuild-sid; pdebuild-breezy"

# aggiornamento

alias pbuilder-update-sid="pbuilder update --basetgz /store3/sid.tgz --mirror http://debian.fastweb.it/debian"
alias pbuilder-update-etch="pbuilder update --basetgz /store3/etch.tgz --mirror http://debian.fastweb.it/debian"
alias pbuilder-update-sarge="pbuilder update --basetgz /store3/sarge.tgz --mirror http://debian.fastweb.it/debian"
alias pbuilder-update-breezy="pbuilder update --basetgz /store3/breezy.tgz --configfile /root/pbuilder-breezy.conf"

# automatizziamo al massimo
alias pbuilder-update-all="pbuilder-update-sarge && pbuilder-update-etch && pbuilder-update-sid && pbuilder-update-breezy"

Esempi

Compilazione per diverse architetture

Se si vuole compilare un pacchetto sorgente per una architettura diversa da quella della propria macchina (es. compilare un pacchetto per "i386" su una macchina "amd64"), è necessario innanzitutto creare l'ambiente "i386":

# pbuilder --architecture i386 --distribution wheezy --basetgz /home/pippo/pbuilder/386wheezy.tgz create

In cui le diverse opzioni significano:

--architecture i386

l'architettura scelta (sono supportate, se si utilizza "debootstrap", solo "i386" e "amd64").

--distribution wheezy

la distribuzione per cui compilare il pacchetto. Si può omettere questa opzione se si intende utilizzare una suite uguale a quella utilizzata dal proprio sistema.

--basetgz /home/pippo/pbuilder/386wheezy.tgz

il percorso e il nome del file .tgz da creare per contenere il nuovo ambiente chroot.

Ora bisogna abilitare il multiarch per poter usare l'architettura "i386":

# dpkg --add-architecture i386

e accertarsi della corretta aggiunta:

# dpkg --print-foreign-architectures
i386

Modificare il file "/etc/apt/sources.list" inserendo:

deb [arch=i386] http://ftp.it.debian.org/debian wheezy main
deb-src [arch=i386] http://ftp.it.debian.org/debian wheezy main

e adattando, eventualmente, queste righe alle proprie esigenze (mirror diverso, release scelta, sezione etc.). Infine eseguire:

# apt-get update

Adesso è tutto pronto per scaricare i file sorgente e lanciare la compilazione. Spostarsi in una directory a propria scelta (magari creata appositamente) e poi:

# apt-get source --download-only apt:i386/wheezy
# pbuilder build --basetgz /home/pippo/pbuilder/386wheezy.tgz apt_0.9.7.9+deb7u7.dsc

Anche in questo caso si devono adattare i comandi in base all'architettura per cui si vuol compilare, alla release scelta e al file .dsc ottenuto con il comando "apt-get source" (in questo caso sono, rispettivamente, "i386", "wheezy" e "apt_0.9.7.9+deb7u7.dsc").
Al termine delle diverse operazioni eseguite da "pbuilder", il pacchetto .deb compilato per architettura "i386" sarà presente nella directory /var/cache/pbuider/result.

Per disabilitare il multiarch e ritornare alla situazione di partenza per il proprio sistema, rimuovere (o commentare) le righe aggiunte al file sources.list e infine:

# dpkg --remove-architecture i386
# dpkg --print-foreign-architectures
# apt-get update

---

Guida scritta da: MaXeR	Debianized 20%
Estesa da:
Verificata da:
Verificare ed estendere la guida | Cos'è una guida Debianized