[[Vorlage(Getestet, jammy)]]
[[Vorlage(Fortgeschritten)]]
{{{#!vorlage Wissen
[:Pakete installieren: Installation von Programmen]
[:Terminal: Ein Terminal öffnen]
[:mit_Root-Rechten_arbeiten:]
[:Paketquellen freischalten: Bearbeiten von Paketquellen]
[:Grundlagen der Paketerstellung:]
[:Launchpad/PPA:Launchpad PPA einrichten]
}}}
[[Inhaltsverzeichnis()]]

Mit '''pbuilder''' lässt sich eine chroot-Umgebung zum [:Paketbau:] erstellen. Für Entwickler 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. Dadurch wird es möglich Pakete zu erstellen, welche nicht nur auf seinem eigenen Computer funktionieren, sonder auch auf anderen. Falls man [:LVM:] verwendet, kann man die Erstellung der chroot-Umgebung beschleunigen (→ [ubuntu:SbuildLVMHowto:] {en}).
Der Befehl '''pbuilder-dist''' unterstützt gegenüber dem ursprünglichen Befehl `pbuilder` komfortabler das Arbeiten mit mehreren unterschiedliche Architekturen und Versionen von Debian und Ubuntu. 

Es wird angenommen, dass [:22.04:Ubuntu 22.04 Jammy Jellyfish] installiert ist. Falls man für eine andere Version bauen möchte, ersetzt man ''jammy'' gegen den Codenamen der zu verwendenden Distribution.

Die Übersetzung des englischen [ubuntu:PbuilderHowto:] {en} befindet sich im [:Archiv/pBuilder:Archiv].

= Installation =
Zunächst werden die nötigen Pakete installiert [1]:
{{{#!vorlage Paketinstallation
pbuilder
ubuntu-dev-tools
debootstrap
devscripts
}}}

Dabei ist die Installation von [packages:devscripts:] nicht unbedingt notwendig, jedoch für den ernsthaften Paketbau empfohlen. Es enthält Werkzeuge wie [man:debsign:] und [man:dget:]. 

= Syntax =
Die Syntax für den Befehl `pbuilder-dist` lautet folgendermaßen:

{{{#!vorlage Befehl
pbuilder-dist DISTRIBUTION [ARCHITEKTUR] OPERATION [OPTION]
}}}

`pbuilder-dist` unterstützt die gleichen Operationen wie [man:pbuilder:].

= Erstellen der Umgebung =
Zuallererst öffnet man ein Terminal [2] und erstellt mit folgendem Befehl einen Archiv mit der chroot-Umgebung zum Paketbau.

{{{#!vorlage Befehl
pbuilder-dist jammy create
}}}

Nach erfolgtem Paketbau finden sich die Binär und Quellpakete unter '''~/pbuilder/jammy_result/'''.

== Umgebung für andere Versionen erstellen ==
Man kann für alle unterstützten und in Entwicklung befindlichen Ubuntu und Debian Versionen jeweils eine chroot-Umgebung erstellen und diese parallel verwenden.

{{{#!vorlage Befehl
pbuilder-dist DISTRIBUTION create
}}}

`DISTRIBUTION` muss man dann durch den entsprechenden Codenamen der gewünschten Version ersetzten.


== 32Bit-Pakete auf einem 64Bit-System bauen ==
Es ist zusätzlich möglich chroot-Umgebung für [:CPU-Architektur:32bit-Betriebsysteme] zu erstellen. Dafür muss man einfach ''"i386"'' hinter dem Namen der zu erstellenden Version setzten:

{{{#!vorlage Befehl
pbuilder-dist DISTRIBUTION i386 create
}}}

== ARM-Pakete auf einem 64Bit-System bauen ==
Mithilfe von [:QEMU:] ist es möglich auch Pakete für Prozessoren auf ARM-Basis zu erstellen. Dafür benötigt man noch folgendes Paket:
{{{#!vorlage Paketinstallation
qemu-user-static, universe
}}}

Nach der Installation kann man Pakete für die Architekturen ''"armhf"'', ''"arm64"'' und ''"armel" (nur Debian)'' bauen. Die dafür benötigten chroot-Umgebungen erstellt man wie oben beschrieben.

Das anschließende Bauen der Pakete unterscheidet sich nicht vom Bau von Paketen für die eigene Architektur. Der einzige Nachteil ist, dass die Kompilierung des Programms wegen der Nutzung von QEMU mehr Zeit beansprucht.

= Bestehende Pakete neu bauen =
Das folgende Beispiel soll zeigen, wie man mithilfe von `pbuilder-dist` schon existierende Debian-Pakete neu bauen kann, um diese beispielsweise selbstständig zu patchen.
Zunächst müssen die Quelltext-Paketquellen (deb-src) eingebunden [4] werden.

Anschließend öffnet man ein Terminal [2] und führt folgenden Befehl mit Root-Rechten [3] aus, um die Paketquellen zu aktualisieren:

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

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

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

Abschließend wird mit dem nächsten Befehl das Paket in die vorbereitete chroot-Umgebung gebaut. Dazu wird die aus dem Quellarchiv entpackte ''.dsc''-Datei, die eine Zusammenfassung des Paketinhalts mit optionaler Signatur enthält, an `pbuilder-dist` übergeben.
`pbuilder-dist` kann immer nur eine ''.dsc''-Datei zur Bearbeitung übergeben werden.

{{{#!vorlage Befehl
pbuilder-dist jammy build dateiname.dsc
}}}

= Pakete neu bauen =
Bevor man mithilfe von `pbuilder-dist` ein Debian-Paket für einen neues Programm bauen kann, muss man erst – falls diese noch nicht existieren – die dafür benötigten Debian-Dateien erstellen [5]. Sobald diese Dateien erfolgreich erstellt sind, öffnet man ein Terminal, wechselt in das Projektverzeichnis, in dem der Ordner mit dem Namen '''"debian"''' liegt, und erzeugt die benötigten Dateien mit `debuild`:

{{{#!vorlage Befehl
debuild -S -sa
}}}
Dieses Hilfsprogramm arbeitet wie folgt:

 1. es ruft `dpkg-buildpackage` zur Paketerstellung auf
 1. dann wird der Paketbau mit `lintian` kontrolliert
 1. Zum Schluss erfolgt die Signierung mit `debsign`

{{{#!vorlage Experten
Dieser Schritt benötigt das Vorhandensein aller Bau-Abhängigkeiten auf dem System. Wenn dies nicht möglich ist, da sie nicht in den entsprechenden Versionen vorliegen, kann auf [man:pdebuild:] ausgewichen werden. Dieser Befehl, um Pakete aus den Kontrolldateien unter '''debian/''' neu zu bauen, greift normalerweise auf
`pbuilder` zurück, kann sich aber durch entsprechende Konfiguration an `pbuilder-dist` anpassen.

Dazu kann eine Datei '''~/.pbuilderrc''' mit folgendem Inhalt angelegt werden:

{{{#!code bash
# Liste der Codenamen. Momentan lediglich Bau für Ubuntu 22.04 erlaubt.
UBUNTU_SUITES=("jammy")

# Paketquellen-Mirror
UBUNTU_MIRROR="ftp.ubuntu.com"

# Anpassung der Pfade an `pbuilder-dist`
BASETGZ="$HOME/pbuilder/$DIST-base.tgz"
DISTRIBUTION="$DIST"
BUILDRESULT="$HOME/pbuilder/${NAME}_result/"
APTCACHE="$HOME/pbuilder/aptcache/"
BUILDPLACE="$HOME/pbuilder/build/"

# Überpfüfung, ob Codename valide ist.
if $(echo ${UBUNTU_SUITES[@]} | grep -q $DIST); then
    # Ubuntu configuration
    MIRRORSITE="http://$UBUNTU_MIRROR/ubuntu/"
    COMPONENTS="main restricted universe multiverse"
    DEBOOTSTRAPOPTS=("${DEBOOTSTRAPOPTS[@]}" "--keyring=/usr/share/keyrings/ubuntu-archive-keyring.gpg")
else
    echo "Unknown distribution: $DIST"
    exit 1
fi
\}}}

Dies bewirkt, das der Bau und die Ablage des Paketes von '''/var/cache/pbuilder/''' in die entsprechenden Verzeichnisse unter '''~/pbuilder/''' verlegt wird.

Nun kann mittels `pdebuild` unter Angabe des Codenamens das Paket gebaut und anschließend signiert werden:

{{{#!vorlage Befehl
DIST=jammy pdebuild --auto-debsign
\}}}

Die Verwendung von `lintian` ist als ''Hook'' möglich. Mehr dazu in [https://www.debian.org/doc/manuals/maint-guide/build.en.html#pbuilder diesem Abschnitt des Debian-Leitfadens für Paketbetreuer] {en}.
}}}

Dabei werden mehrere Dateien im übergeordneten Ordner erzeugt, u.a. '''Projektname_Version-Revisionsnummer_Architektur.dsc''' und '''Projektname_Version-Revisionsnummer_Architektur.changes'''. War die Erstellung des Projekts nicht erfolgreich, müssen mit den Hinweisen von `lintian` die Fehler in der Paketkonfiguration ermittelt und korrigiert werden.

Anschließend wechselt man in den übergeordneten Ordner und lässt das Paket mithilfe von `pbuilder-dist` bauen:

{{{#!vorlage Befehl
cd .. && pbuilder-dist jammy build dateiname.dsc
}}}

Das fertige Paket befindet sich – nach dem erfolgreichen Bau – unter '''~/pbuilder/jammy_result/'''.

= chroot aktualisieren =
Es wird empfohlen, den chroot vor jedem Bau zu aktualisieren:

{{{#!vorlage Befehl
pbuilder-dist jammy update
}}}

= Pakete aus einem PPA einbinden =
Das Einbinden eines PPAs[6] ist etwas komplizierter und wird hierbei am Beispiel des [launchpad:~gnome3-team/+archive/ubuntu/gnome3:GNOME3] PPAs erläutert.

Möchte man ein PPA in eine chroot-Umgebung  einbinden, dann braucht man als erstes den Signierschlüssel des PPAs. Diesen findet man auf der Launchpad-Seite des  [launchpad:~gnome3-team/+archive/ubuntu/gnome3:PPAs] unter ''"Technical details about this PPA"'' → ''"Signing key:"''.

Um diesen Signierschlüssel nun in die chroot-Umgebung zu importieren meldet man sich zuerst bei dieser an:
{{{#!vorlage Befehl
pbuilder-dist jammy login --save-after-login
}}}
und fügt den Schlüssel mit folgender Befehlsfolge ([:GnuPG:] ist nicht vorhanden und muss nachinstalliert werden) hinzu:
{{{#!vorlage Befehl
apt install gpg dirmngr gpg-agent
export HOME="/root"
mkdir -m700 $HOME/.gnupg/
dirmngr --daemon
gpg --no-default-keyring --keyring /etc/apt/keyrings/gnome3-archive-keyring.gpg --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 9D542E3D52C801D9F8E31682F1773AF13B1510FD
}}}
Zuletzt verlässt man die chroot-Umgebung wieder.
{{{#!vorlage Befehl
exit
}}}

Nun kann das PPA mit folgendem Befehl hinzugefügt werden:
{{{#!vorlage Befehl
pbuilder-dist jammy update --override-config --othermirror "deb [signed-by=/etc/apt/keyrings/gnome3-archive-keyring.gpg] http://ppa.launchpad.net/gnome3-team/gnome3/ubuntu jammy main" 
}}}
Nun kann man wie oben beschrieben seine Pakete erstellen und dabei auf die eingebundenen PPAs zugreifen.

{{{#!vorlage Hinweis
Haben sich die Pakete im PPA verändert, dann empfiehlt es sich die chroot-Umgebung mit vorherigen Befehl zu aktualisieren.
}}}

= Beispiele =
Im folgenden noch ein paar Beispiele, wie `pbuilder-dist` verwendet werden kann:

Eine Umgebung für Debian Sid erstellen:
{{{#!vorlage Befehl
pbuilder-dist sid create
}}}

Eine Umgebung für Ubuntu [:Jammy:] mit 32Bit-Architektur:
{{{#!vorlage Befehl
pbuilder-dist jammy i386 create
}}}

Die chroot-Umgebung aktualisieren:
{{{#!vorlage Befehl
pbuilder-dist jammy update
}}}

Ein Paket mit Ubuntu [:Jammy:] als chroot-Umgebung auf Grundlage der ''.dsc''-Datei bauen:
{{{#!vorlage Befehl
pbuild-dist jammy build dateiname.dsc
}}}

Das Paket für die 32Bit-Architektur bauen:
{{{#!vorlage Befehl
pbuild-dist jammy i386 build dateiname.dsc
}}}


= Links =
 * [https://wiki.ubuntu.com/PbuilderHowto#Using_pbuilder-dist_to_manage_different_architectures_and_distro_releases Abschnitt für `pbuilder-dist` im PbuilderHowto] {en}
 * [:Grundlagen der Paketerstellung:]
 * [:Launchpad/PPA:] – Pakete in Lauchpad hochladen
 * [man:pbuilder-dist:] {en} – Ubuntu Manpage

#tag: Paketverwaltung, Paketbau