[[Vorlage(Archiviert)]]
[[Vorlage(Fortgeschritten)]]
{{{#!vorlage Hinweis
Dieser Artikel ist eine Übersetzung des englischen [ubuntu:PbuilderHowto:] {en} und steht unter der [ubuntu:DocumentationTeam/License:] {en} [http://creativecommons.org/licenses/by-sa/2.5/deed.de Creative Commons Namensnennung-Weitergabe unter gleichen Bedingungen 2.5] {de}
}}}
{{{#!vorlage Wissen
[:Pakete installieren: Installation von Programmen]
[:Terminal: Ein Terminal öffnen]
[:sudo: Root-Rechte]
[:Paketquellen freischalten: Bearbeiten von Paketquellen]
[:Editor: Einen Editor öffnen]
[:Grundlagen der Paketerstellung:]
}}}
[[Inhaltsverzeichnis()]]

Mit '''pbuilder''' lässt sich eine chroot-Umgebung zum [:Paketbau:] erstellen. Für Maintainer von Ubuntu oder Debianpaketen wird dieses Vorgehen empfohlen. Man kann auch ohne pbuilder Pakete bauen, aber man muss alle ''build dependencies'' des Paketes auf dem laufenden System installieren. Falls man [:LVM:] verwendet, kann man die Erstellung der chroot-Umgebung beschleunigen (→ [ubuntu:SbuildLVMHowto:] {en}) Im folgenden wird angenommen, dass Ubuntu 10.04 [:Lucid Lynx:] installiert ist. Falls man eine andere Version besitzt ersetzt man ''lucid'' gegen den Codenamen der verwendeten Distribution.

= Installation =
Zunächst werden die nötigen Pakete installiert [1] wobei devscripts nicht unbedingt nötig ist, jedoch für den ernsthaften Paketbau empfohlen wird.
{{{#!vorlage Paketinstallation
pbuilder
debootstrap
devscripts
}}}
Alsdann öffnet man eine Konsole [2] und erstellt mit folgendem Befehl einen Archiv mit der chroot-Umgebung zum Paketbau. Hierfür werden Root-Rechte benötigt.[3]

{{{#!vorlage Befehl
sudo pbuilder create
}}}

Um die Umgebung den offiziellen Paketbaurechnern anzunähern kann man folgende Parametern verwenden:

{{{#!vorlage Befehl
sudo pbuilder create --debootstrapopts --variant=buildd
}}}

Die Variante ''buildd'' installiert die ''build-essential'' Pakete in der chroot-Umgebung.

Wenn alles geklappt hat, sollte jetzt ein tar-Archiv mit dem Namen '''base.tgz''' im System unter '''/var/cache/pbuilder''' liegen.

= Ein bestehendes Paket aus den Paketquellen neu aus dem Quelltext bauen =
Zunächst müssen die Quelltext-Paketquellen (deb-src) eingebunden [4] werden.

Anschließend öffnet man ein Terminal [2] und gibt folgenden Befehl ein bei man wieder nach seinem Root-Passwort gefragt wird:

{{{#!vorlage Befehl
sudo apt-get update
}}}

Im folgenden werden die Quelltexte von '''bc''', einem einfachen Taschenrechner heruntergeladen:

{{{#!vorlage Befehl
apt-get source bc
}}}

Anschließend wird das Paket im vorbereiteten chroot-Reinraum gebaut:

{{{#!vorlage Befehl
sudo pbuilder build *.dsc
}}}

Nach erfolgtem Paketbau finden sich die Binär und Quellpakete unter '''/var/cache/pbuilder/result/'''

= chroot aktualisieren =
Es wird empfohlen den chroot täglich vor jedem Bau zu aktualisieren:

{{{#!vorlage Befehl
sudo pbuilder update
}}}

= chroot auf eine andere Ubuntuversion aktualisieren =

Für ein neues Paket für die Entwicklungsversion von Ubuntu muss auch die chroot-Umgebung neu erstellt werden. Hierbei geht man wie bei [#Installation Installation] vor und gibt dann folgenden Befehl ein, wobei DIST-NAME der Codename der Entwicklerversion (momentan `precise`) ist.

{{{#!vorlage Befehl
sudo pbuilder update --distribution DIST-NAME --override-config
}}}

Dies aktualisiert die chroot-Umgebung auf die angegebene Version und übergeht die Konfigurationsdateien.

= Berechnung der build-depency beschleunigen =
Ab 7.04 [:Feisty Fawn:] kann man einen neuen Abhängigkeitenauflöser basierend auf [:Paketinstallation DEB:gdebi], was bedeutend schneller geht. Hierfür muss die Datei '''~/.pbuilderrc''' in einem Texteditor geöffnet werden [5] und folgende Zeile ergänzt werden:

{{{
PBUILDERSATISFYDEPENDSCMD="/usr/lib/pbuilder/pbuilder-satisfydepends-gdebi"
}}}

== Probleme mit pbuilder-satisfydepends-gdebi und lokalen Paketquellen ==
Falls man eine lokale übergelegte Paketquelle verwendet (eine fortgeschrittene Anwendung von pbuilder, die normalerweise für [:Paketquellen#Neuere-Programme-Backports-und-Extras:Backports] verwendet wird), muss eine modifizierte Version von `pbuilder-satisfydepends-gdebi` verwendet werden. Man öffnet ein Terminal [2] und kopiert den Abhängigkeitsauflöser und macht ihn ausführbar:

{{{#!vorlage Befehl
cp /usr/lib/pbuilder/pbuilder-satisfydepends-gdebi ~/.pbuilder-satisfydepends-gdebi
chmod +x ~/.pbuilder-satisfydepends-gdebi
}}}

Dann öffnet man einen Texteditor [5] und ändert Zeile 80 von '''~/.pbuilder-satisfydepends-gdebi''' um Warnungen von lokalen Paketquellen, die nicht im Ubuntu-Schlüsselbund sind zu ignorieren.

Die Zeile

{{{
$CHROOTEXEC /usr/bin/apt-get install -y $INSTALL
}}}

ändern in:

{{{
$CHROOTEXEC /usr/bin/apt-get install -y --force-yes $INSTALL
}}}

Dann ändert man noch '''~/.pbuilderrc''' dahingehend, dass die modifizierten Abhängigkeitsauflösungsskripte verwendet werden sollen:

{{{
PBUILDERSATISFYDEPENDSCMD="~/.pbuilder-satisfydepends-gdebi"
}}}

= Integration mit ccache =
Zur Verwendung mit [:Compiler#Hilfreiche-Tools:ccache] muss mit einem Texteditor [5] folgendes zu '''~/.pbuilderrc''' hinzugefügt werden:

{{{
# ccache
sudo mkdir -p /var/cache/pbuilder/ccache
sudo chmod a+w /var/cache/pbuilder/ccache
export CCACHE_DIR="/var/cache/pbuilder/ccache"
export PATH="/usr/lib/ccache:${PATH}"
EXTRAPACKAGES=ccache
BINDMOUNTS="${CCACHE_DIR}"
}}}

Jetzt wird pbuilder automatisch die Compilerausgaben zwischenspeichern.

= Universe-Unterstützung =
Falls man ein Paket aus [:Paketquellen#Universe:Universe] oder ein neues bauen möchte, welches daraus ein Paket benötigt muss folgendes mit einem Texteditor [5] zu '''~/.pbuilderrc''' hinzugefügt werden:

{{{
COMPONENTS="main restricted universe multiverse"
}}}

Danach muss die chroot-Umgebung aktulaisiert werden:

{{{#!vorlage Befehl
sudo pbuilder update --override-config
}}}

= i386-Pakete auf einer AMD64 Maschine bauen =
Man kann eine i386-chroot-Umgebung mit folgenden Befehl erstellen:

{{{#!vorlage Befehl
sudo pbuilder create --debootstrapopts --arch --debootstrapopts i386
}}}

= mehrere pbuilder =
Falls man sowohl Backports als auch Pakete für die Entwicklungsversion erstellt möchte man parallel mehrere pbuilder-Umgebungen haben. Es ist auch möglich [ubuntu:ContributingToDebian:Pakete für Debian] {en} zu bauen.

== debootstrap aktualisieren ==
Es wird empfohlen eine aktualisierte Version von debootstrap aus den Backports [:Paketquellen:] zu installieren. Die aktualisierte Version unterstützt neuere Distributionen wie den aktuellen Entwicklungszweig von Ubuntu.

== base.tgz Ort ändern ==
Die einzige Anforderung um pbuilder für mehrere Distributionen zu verwenden ist ein alternativer Ort um das Archiv für die pbuilder-Umgebung zu lagern. In der Kommandozeile kann dies durch die `basetgz`-Option angegeben werden. Bequemer ist es jedoch folgendes mit einem Texteditor in die '''~/.pbuilderrc''' einzugeben um dies zu automatisieren:

{{{
# Codenamen für Debian Veröffentlichungen
UNSTABLE_CODENAME="sid"
TESTING_CODENAME="squeeze"
STABLE_CODENAME="lenny"
STABLE_BACKPORTS_SUITE="$STABLE_CODENAME-backports"

# Liste von Debianversionen
DEBIAN_SUITES=($UNSTABLE_CODENAME $TESTING_CODENAME $STABLE_CODENAME
    "unstable" "testing" "stable")

# Liste von Ubuntuversionen
UBUNTU_SUITES=("precise" "oneiric" " "lucid" )

# verwendete Mirrorserver
DEBIAN_MIRROR="ftp.us.debian.org"
UBUNTU_MIRROR="mirrors.kernel.org"

# Wenn keine Version gesetzt ist, aus dem changelog auslesen.
if [ -z "${DIST}" ] && [ -r "debian/changelog" ]; then
    DIST=$(dpkg-parsechangelog | awk '/^Distribution: / {print $2}')
    # unstable bei bestimmten Werten verwenden
    if $(echo "experimental UNRELEASED" | grep -q $DIST); then
        DIST="$UNSTABLE_CODENAME"
    fi
fi

# optional: eine Standarddistribution wählen falls keine Angabe verwendet wird
# Man kann einen eigenen Standard definieren: ${DIST:="unstable"}
: ${DIST:="$(lsb_release --short --codename)"}

# optional: den Debianveröffentlichungsstatus in $DIST Namen zuordnen
case "$DIST" in
    unstable)
        DIST="$UNSTABLE_CODENAME"
        ;;
    testing)
        DIST="$TESTING_CODENAME"
        ;;
    stable)
        DIST="$STABLE_CODENAME"
        ;;
esac

# optional: die Architektur der setzen, falls keine angegeben ist
# Man kann seinen eigenen Standard setzen: ${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"
# optional: BASEPATH anstelle von BASETGZ setzen, falls cowbuilder verwendet wird
# 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 Konfiguration
    MIRRORSITE="http://$DEBIAN_MIRROR/debian/"
    COMPONENTS="main contrib non-free"
    # Dies aktiviert backports für die Debian stable Veröffentlichung
    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 Konfiguration
    MIRRORSITE="http://$UBUNTU_MIRROR/ubuntu/"
    COMPONENTS="main restricted universe multiverse"
else
    echo "Unknown distribution: $DIST"
    exit 1
fi
}}}

{{{#!vorlage Hinweis
Es gibt optionale Angaben in diesem Schnipsel, die mit "optional:" vor dem Kommentar gekennzeichnet sind. Entweder sollten diese auskommentiert werden oder an die eigenen Bedürfnisse angepasst werden.
}}}

Jetzt wird der Ort des tarballs automatisch geändert, wenn ein Benutzer DIST ändert und dann pbuilder mit dem Parameter `--override-config` ausführt. Die Variablen BUILDRESULT oder APTCACHE zu verwenden ist optional, aber möglicherweise hilfreich.

Falls ARCH auf eine andere Architektur gesetzt ist wenn pbuilder ausgeführt wird, wird pbuilder eine entsprechende Umgebung erstellen.

== Beispiele ==
Eine Umgebung für Ubuntu [:Precise:]
{{{#!vorlage Befehl
sudo DIST=precise pbuilder create
}}}

Eine Umgebung für Debian sid
{{{#!vorlage Befehl
sudo DIST=sid pbuilder create
}}}

Eine Umgebung für Ubuntu [:Lucid:] mit i386-Architektur
{{{#!vorlage Befehl
sudo DIST=lucid ARCH=i386 pbuilder create
}}}

Die Basisumgebung für [:Lucid:] aktualisieren
{{{#!vorlage Befehl
sudo DIST=lucid pbuilder update
}}}

Ein Paket mit Ubuntu [:Lucid:] als Basisumgebung bauen
{{{#!vorlage Befehl
DIST=lucid pdebuild
}}}

Ein Paket mit Ubuntu [:Lucid:] als Basisumgebung und i386-Architektur bauen
{{{#!vorlage Befehl
DIST=lucid ARCH=i386 pdebuild
}}}

= mit lokalen Paketen bauen =
Manchmal hängt ein zu bauendes Paket von einer neueren Version eines anderen Paketes ab, dass sich nicht im Ubuntu- oder Debianarchiv befindet oder sich dort noch überhaupt nicht befindet. Für diesen Fall erstellt man Pakete und lädt sie in [:Lokale Paketquellen:] hoch.

== Installation ==
Zunächst werden die nötigen Pakete installiert.[1]
{{{#!vorlage Paketinstallation
dput
mini-dinstall, universe
}}}

Nun erstellt man mit einem Texteditor eine Datei namens '''.mini-dinstall.conf''' im [:Homeverzeichnis:] mit folgendem Inhalt:

{{{
[DEFAULT]
architectures = all, i386, amd64, powerpc
archivedir = /var/cache/archive/
use_dnotify = 0
verify_sigs = 0
extra_keyrings = ~/.gnupg/pubring.gpg
mail_on_success = 0
archive_style = flat
poll_time = 10
mail_log_level = NONE

[sid]

[lenny]

[lucid]
}}}

Diese Konfigurationsdatei ist eine Abwandlung aus der Dokumenation von mini-dinstall ('''/usr/share/doc/mini-dinstall''').Unter Architektur wählt man diejenige des verwendeten Rechners. Die Auflistung von `[sid]`, `[maverick]`, usw. erlaubt Pakete mit dput für die jeweilige Debian- und Ubuntuversion hochzuladen.

Dann öffnet man '''~/.dput.cf''' mit einem Texteditor und ändert den Absatz nach `[local]` folgendermaßen:

{{{
[local]
method = local
incoming = /var/cache/archive/mini-dinstall/incoming
allow_non-us_software = 1
run_dinstall = 0
post_upload_command = mini-dinstall --batch
}}}

Jetzt erstellt man ein Verzeichnis namens '''incoming''' und gibt sich selbst die nötigen Schreibrechte:
{{{#!vorlage Befehl
sudo mkdir -p /var/cache/archive/mini-dinstall/incoming
sudo chown -R $USER /var/cache/archive/
}}}

== in ein lokales Dateisystem hochladen ==

Sobald ein Paket fertig gebaut ist, kann es in das lokale Dateisystem hochgeladen werden:

{{{#!vorlage Befehl
dput local *.changes
}}}

Mit der obigen Konfiguration sollte es folgendermaßen aussehen '''/var/cache/archive/<distro-version>''', wobei <distro-version> entweder sid, lucid, usw. abhängig von der Distribution für die gebaut wurde. In dem Verzeichnis sollten die Pakete und Quelldateien zusammen mit den hochgeladenen Paketen liegen.

== mit lokalen Paketquellen aktualisieren ==

Jetzt ändert man die Konfigurationsdatei '''.pbuilderrc''' in den folgenden Schnipsel:

{{{
# Codenamen für Debian Veröffentlichungen
UNSTABLE_CODENAME="sid"
TESTING_CODENAME="squeeze"
STABLE_CODENAME="lenny"
STABLE_BACKPORTS_SUITE="$STABLE_CODENAME-backports"

# Liste von Debianversionen
DEBIAN_SUITES=($UNSTABLE_CODENAME $TESTING_CODENAME $STABLE_CODENAME
    "unstable" "testing" "stable")

# Liste von Ubuntuversionen
UBUNTU_SUITES=("precise" "oneiric" "natty" "lucid" "hardy")

# verwendete Mirrorserver
DEBIAN_MIRROR="ftp.us.debian.org"
UBUNTU_MIRROR="mirrors.kernel.org"

# Wenn keine Version gesetzt ist, aus dem changelog auslesen.
if [ -z "${DIST}" ] && [ -r "debian/changelog" ]; then
    DIST=$(dpkg-parsechangelog | awk '/^Distribution: / {print $2}')
    # unstable bei bestimmten Werten verwenden
    if $(echo "experimental UNRELEASED" | grep -q $DIST); then
        DIST="$UNSTABLE_CODENAME"
    fi
    # Verwende stable für stable-backports
    if $(echo "$STABLE_BACKPORTS_SUITE" | grep -q $DIST); then
        DIST="$STABLE"
    fi
fi

# optional: eine Standarddistribution wählen falls keine Angabe verwendet wird
# Man kann einen eigenen Standard definieren: ${DIST:="unstable"}
: ${DIST:="$(lsb_release --short --codename)"}

# optional: den Debianveröffentlichungsstatus in $DIST Namen zuordnen
case "$DIST" in
    unstable)
        DIST="$UNSTABLE_CODENAME"
        ;;
    testing)
        DIST="$TESTING_CODENAME"
        ;;
    stable)
        DIST="$STABLE_CODENAME"
        ;;
esac

# optional: die Architektur der setzen, falls keine angegeben ist
# Man kann seinen eigenen Standard setzen: ${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"
# optional: BASEPATH anstelle von BASETGZ setzen, falls cowbuilder verwendet wird
# 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/"
BINDMOUNTS="/var/cache/archive"

if $(echo ${DEBIAN_SUITES[@]} | grep -q $DIST); then
    # Debian Konfiguration
    MIRRORSITE="http://$DEBIAN_MIRROR/debian/"
    COMPONENTS="main contrib non-free"
    # Dies aktiviert backports für die Debian stable Veröffentlichung
    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 Konfiguration
    MIRRORSITE="http://$UBUNTU_MIRROR/ubuntu/"
    COMPONENTS="main restricted universe multiverse"
    OTHERMIRROR="deb file:///var/cache/archive $DIST/"
else
    echo "Unknown distribution: $DIST"
    exit 1
fi
}}}

Jetzt muss man pbuilder aktualisieren. Hierfür muss pbuilder mit dem `override-config`-Parameter gestartet werden:

{{{#!vorlage Befehl
sudo DIST=hardy pbuilder update \
--override-config \
--configfile ~/.pbuilderrc
}}}

Nach der Aktualisierung jeder Basisumgebung sollten die lokalen Paketquellen verwendet werden. Nun kann man die pbuilder Befehle wie oben benutzen.

= ein 32-bit Paket auf einer 64-bit Maschine oder für ältere Ubuntuversionen bauen =

Um für anderen Distributionen oder Architekturen zu bauen kann man '''pbuilder-dist''' verwenden.

== Syntax ==

{{{#!vorlage Befehl
pbuilder-dist distribution [architecture] [mainonly] operation ...
}}}

== Beispiele ==
Zunächst muss create aufgerufen werden wie beim normalen pbuilder
{{{#!vorlage Befehl
pbuilder-dist lucid i386 create
}}}

Für [:Lucid Lynx:] i386 bauen:
{{{#!vorlage Befehl
pbuilder-dist lucid i386 build *.dsc
}}}

Die erstellten Pakete werden unter '''~/pbuilder/DIST-ARCH_result''' und nicht in '''/var/cache/pbuilder/result''' abgelegt.

== Unterschiede zu pbuilder ==
pbuilder-dist unterstützt noch nicht alle Befehle. Beispielsweise funktioniert folgendes nicht richtig:
{{{#!vorlage Befehl
sudo pbuilder-dist lucid i386 update --override-config --othermirror "deb http://ppa.launchpad.net/cae-team/ppa/ubuntu karmic main"
}}}

Wenn man also eine Paketquelle hinzufügen möchte, muss man ''OTHERMIRROR'' in '''~/.pbuilderrc''' wie folgt hinzufügen:
{{{
OTHERMIRROR="deb http://ppa.launchpad.net/cae-team/ppa/ubuntu karmic main"
}}}

= Weblinks =
 * [http://pbuilder.alioth.debian.org/pbuilder-doc.html pbuilder Handbuch] ([http://pbuilder.alioth.debian.org/pbuilder-doc.pdf PDF-Download]) {en}

#tag: Paketverwaltung, Paketbau