Poudriere Anleitung

Das Ports-System ist eines der größten Vorteile von FreeBSD für Benutzer, die Flexibilität und Kontrolle über ihre Software wünschen. Es ermöglicht Administratoren das einfache Erstellen und Verwalten von quellenbasierten Installationen mithilfe eines Systems, das robust und vorhersehbar ist.

Während die Vorteile dieser Funktion groß sind, sind einige der am häufigsten gegen die portsbasierte Verwaltung erhobenen Beschwerden die Zeit und die Ressourcen, die für die Kompilierung der einzelnen Softwareprogramme erforderlich sind. Dies wird noch problematischer, wenn Sie eine große Anzahl von Servern verwalten, von denen jeder seine eigenen Ports kompiliert. Während FreeBSD-Pakete eine Alternative bieten, die die Installation beschleunigt, opfert sie die Kontrolle, die Ports gewähren.

Um dieses Problem zu beheben, können Administratoren eine Anwendung namens Poudriere verwenden, um benutzerdefinierte Pakete zu erstellen und zu verwalten. Während es technisch so angelegt ist, dass es Pakete für eine Vielzahl von Architekturen erstellt, wird Poudriere oft als eine Paketerstellungsumgebung verwendet, um Pakete für eine gesamte Infrastruktur von FreeBSD-Servern zu erstellen und zu hosten.

Installieren der erforderlichen Pakete

Zu Beginn werden wir alle benötigten Ports installieren.

Zuerst müssen wir Poudriere selbst installieren.

pkg install poudriere

Schließlich wollen wir auch einen Webserver installieren. Dies wird zwei Zwecken dienen. Erstens wird dies die Methode sein, mit der unsere Maschinen die Pakete herunterladen können, die wir kompilieren werden. Zweitens bietet Poudriere eine Weboberfläche, so dass wir den Build-Prozess verfolgen und Protokolle überwachen können. In unserem Fall verwenden wir den NGINX Webserver:

pkg install nginx

Erstellen eines SSL-Zertifikats und eines Schlüssels

Wenn wir Pakete mit Poudriere erstellen, wollen wir sie mit einem privaten Schlüssel signieren können. Dies stellt sicher, dass all unsere Maschinen die erstellten Pakete legitimieren und dass niemand die Verbindung zum Build-Rechner abfängt, um schädliche Pakete zu versenden.

Wir werden sicherstellen, dass wir ein SSL-Verzeichnis haben, das zwei Unterverzeichnisse enthält, die keys und certs genannt werden. Wir können dies in einem Befehl tun, indem wir Folgendes eingeben:

mkdir -p /usr/local/etc/ssl/{keys,certs}

Unser privater Schlüssel, der geheim gehalten werden muss, wird im Schlüsselverzeichnis abgelegt. Dies wird verwendet, um die Pakete zu signieren, die wir erstellen werden. Wir können das Verzeichnis sperren, damit Benutzer ohne Root- oder Sudoprivilegien nicht mit dem Verzeichnis oder seinen Inhalten interagieren können:

chmod 0600 /usr/local/etc/ssl/keys

Als Nächstes erzeugen wir einen 4096-Bit-Schlüssel namens poudriere.key und platzieren ihn in unserem keys Verzeichnis, indem wir Folgendes eingeben:

openssl genrsa -out /usr/local/etc/ssl/keys/poudriere.key 4096

Nachdem der Schlüssel generiert wurde, können wir ein öffentliches Zertifikat daraus erstellen, indem wir Folgendes eingeben:

openssl rsa -in /usr/local/etc/ssl/keys/poudriere.key -pubout -out /usr/local/etc/ssl/certs/poudriere.cert

Wir haben jetzt die SSL-Komponenten, die wir benötigen, um Pakete zu signieren und die Signaturen zu verifizieren. Später werden wir unsere Clients so konfigurieren, dass sie das generierte Zertifikat für die Paketverifizierung verwenden.

Konfigurieren von Poudriere

Jetzt wo wir unser SSL Zertifikat und Schlüssel haben, können wir mit der Konfiguration von Poudriere beginnen.

Die Hauptkonfigurationsdatei befindet sich unter /usr/local/etc/poudriere.conf. Öffnen Sie diese Datei:

nano /usr/local/etc/poudriere.conf

Die Poudriere-Konfigurationsdatei ist sehr gut kommentiert und die meisten Einstellungen müssen vordefiniert sein. Wir werden einige spezifische Änderungen vornehmen, aber die Mehrheit davon intakt lassen.

Wenn wir als Dateisystem UFS verwenden muss die folgende Option auskommentiert werden:

NO_ZFS=yes

Wenn unser Server andererseits ZFS verwendet, können wir poudriere für die Verwendung eines bestimmten Pools konfigurieren, indem wir die Option ZPOOL festlegen. In diesem Pool können wir den Stamm angeben, den Poudriere für Pakete, Protokolle usw. mit der Option ZROOTFS verwenden soll. Wir müssen beachten, dass diese beiden Optionen nicht festgelegt werden sollten, wenn die Option NO_ZFS auf „yes“ gesetzt ist:

# NO_ZFS=yes
ZPOOL=tank
ZROOTFS=/poudriere

Beim Erstellen von Software verwendet Poudriere eine Art von Jail, um das Build-System vom Hauptbetriebssystem zu trennen. Als Nächstes müssen wir einen gültigen Host ausfüllen, wo der Build-Rechner die Software herunterladen kann, die er für die Jails benötigt. Dies wird über die FREEBSD_HOST-Option konfiguriert.

Diese Option sollte bereits vorhanden sein, obwohl sie derzeit nicht auf einen gültigen Host festgelegt ist. Wir können dies auf den Standardpfad ftp://ftp.freebsd.org ändern oder einen engeren Spiegel verwenden, wenn wir einen kennen:

FREEBSD_HOST=https://download.freebsd.org

Als Nächstes wollen wir sicher sein, dass unser Datenverzeichnis innerhalb der Poudriere-Wurzel korrekt eingestellt ist. Dies wird mit der Option POUDRIERE_DATA gesteuert und sollte standardmäßig eingestellt werden. Wir werden die Option jedoch auskommentieren, um sicherzugehen:

POUDRIERE_DATA=${BASEFS}/data

Die nächsten Optionen, die wir auskommentieren sollten, sind die Optionen CHECK_CHANGED_OPTIONS und CHECK_CHANGED_DEPS. Die erste Option weist Poudriere an, Pakete neu zu erstellen, wenn sich die Optionen dafür geändert haben. Die zweite Option weist Poudriere an, Pakete neu zu erstellen, wenn sich Abhängigkeiten seit der letzten Kompilierung geändert haben.

Beide Optionen existieren in der Form, die wir in der Konfigurationsdatei haben wollen. Wir müssen sie nur auskommentieren:

CHECK_CHANGED_OPTIONS=verbose
CHECK_CHANGED_DEPS=yes

Als Nächstes werden wir Poudriere auf den SSL-Schlüssel zeigen, den wir erstellt haben, damit Pakete während des Builds signiert werden können. Die zur Angabe verwendete Option heißt PKG_REPO_SIGNING_KEY. Wir heben die Markierung dieser Option auf und ändern den Pfad so, dass er den Speicherort des SSL-Schlüssels widerspiegelt, den wir zuvor erstellt haben:

PKG_REPO_SIGNING_KEY=/usr/local/etc/ssl/keys/poudriere.key

Schließlich können wir die URL_BASE-Zeichenfolge auf den Domänennamen oder die IP-Adresse festlegen, unter dem unser Server erreichbar ist. Dies wird von Poudriere verwendet, um Links in der Ausgabe zu erstellen, auf die geklickt werden kann. Wir sollten das Protokoll einschließen und den Wert mit einem Schrägstrich beenden:

URL_BASE=http://server_domain_or_IP/

Wenn wir mit den Änderungen fertig sind, speichern und schließen wir die Datei.

Erstellen der Build-Umgebung

Als Nächstes müssen wir unsere Build-Umgebung konstruieren. Wie bereits erwähnt, wird Poudriere Ports in einer isolierten Umgebung mit Jails bauen.

Für unsere Zwecke sieht unser Jails-Aufbaubefehl so aus:

poudriere jail -c -j 12-0x64 -v 12.0-RELEASE

Das wird eine Weile dauern, also seid geduldig. Wenn es fertig ist, können wir das installierte sehen, indem wir Folgendes eingeben:

poudriere jail -l

Ausgabe:

JAILNAME        VERSION         ARCH  METHOD TIMESTAMP           PATH
12-0x64 12.0-RELEASE-p6 amd64 ftp    2018-01-06 20:43:48 /usr/local/poudriere/jails/12-0x64

Sobald wir eine Jail erstellt haben, müssen wir eine Ports-Struktur installieren.

Wir können das Flag -p verwenden, um unseren Ports-Baum zu benennen. Wir werden unseren Baum HEAD nennen, da er genau die Verwendung dieses Baumes (den „Kopf“ oder den aktuellsten Punkt des Baumes) zusammenfasst. Wir werden es regelmäßig aktualisieren, damit es der aktuellsten Version der verfügbaren Ports-Struktur entspricht:

poudriere ports -c -p HEAD

Auch diese Prozedur wird eine Weile dauern, da die gesamte Ports-Struktur abgerufen und extrahiert werden muss. Wenn dies abgeschlossen ist, können wir unseren Ports-Baum anzeigen, indem wir Folgendes eingeben:

poudriere ports -l

Nachdem dieser Schritt abgeschlossen ist, haben wir nun die Strukturen, um unsere Ports zu kompilieren und Pakete zu erstellen. Als Nächstes können wir damit beginnen, unsere Liste von Ports zusammenzustellen, um die Optionen zu erstellen und zu konfigurieren, die wir für jede Software benötigen.

Erstellen einer Port-Building-Liste und Festlegen von Port-Optionen

Wir werden eine Liste von Ports erstellen, die wir direkt Poudriere übergeben können.

Die Datei sollte die Port-Kategorie gefolgt von einem Schrägstrich und dem Port-Namen auflisten, um ihre Position in der Ports-Struktur widerzuspiegeln:

port_category/first_port
port_category/second_port
port_category/third_port

Alle erforderlichen Abhängigkeiten werden ebenfalls automatisch erstellt. Wir müssen also nicht die gesamte Abhängigkeitsstruktur der Ports aufspüren, die wir installieren möchten. Wir können diese Datei manuell erstellen, aber wenn unser Basissystem bereits die meiste Software installiert hat, können wir die Datei automatisch erstellen.

Bevor wir dies tun, ist es in der Regel eine gute Idee, alle nicht benötigten Abhängigkeiten von unserem System zu entfernen, um die Portliste so sauber wie möglich zu halten. Wir können dies tun, indem wir Folgendes eingeben:

pkg autoremove

Danach können wir eine Liste der Software, die wir explizit auf unserem Build-System installiert haben, erhalten:

pkg query -e "%a==0" "%o" | sort -d | tee /usr/local/etc/poudriere.d/port-list 

Wenn es Ports gibt, die wir nicht hinzufügen möchten, entfernen wir die zugehörige Zeile. Dies ist auch eine Gelegenheit, zusätzliche Ports hinzuzufügen, die wir möglicherweise benötigen.

Wenn wir zum Erstellen unserer Ports bestimmte make.conf-Optionen verwenden, können wir für jede Jail innerhalb unseres Verzeichnisses /usr/local/etc/poudriere.d eine Datei make.conf erstellen. Zum Beispiel können wir für unser Jail eine make.conf-Datei mit diesem Namen erstellen:

nano /usr/local/etc/poudriere.d/12-0x64-make.conf 

Ich persönlich erstelle lieber eine globale make.conf die für alle Jails gültig ist.

nano /usr/local/etc/poudriere.d/make.conf

Im Inneren können wir alle Optionen angeben, die wir beim Erstellen unserer Ports verwenden möchten. Wenn wir beispielsweise keine Dokumentation, Beispiele, Unterstützung für die Muttersprache oder X11-Unterstützung erstellen möchten, können wir Folgendes festlegen:

OPTIONS_UNSET+= DOCS NLS X11 EXAMPLES

Sie können aber auch Default_Versions angeben. In meinem Fall schaut es so aus:

DEFAULT_VERSIONS+= gcc=7 linux=c7 mysql=10.3m php=7.2 samba=4.7 ssl=openssl

In diesem Fall werden alle Pakete und/oder deren Abhängigkeiten mit der angegebenen Version gebaut.

Danach können wir jeden unserer Ports konfigurieren, der Dateien mit den ausgewählten Optionen erstellt.

Wir können alles konfigurieren, das noch nicht mit dem Befehl options konfiguriert wurde. Wir sollten sowohl den Port-Baum, den wir erstellt haben (mit der Option -p), als auch das Jail, für das wir diese Optionen festlegen (mit der Option -j), übergeben. Wir müssen auch die Liste der Ports angeben, die wir mit der Option -f konfigurieren möchten.

poudriere options -j 12-0x64 -p HEAD -f /usr/local/etc/poudriere.d/port-list

Wir sehen einen Dialog für jeden der Ports in der Liste und alle Abhängigkeiten, für die keine entsprechenden Optionen im Verzeichnis -options festgelegt sind. Die Angaben in unserer Datei make.conf werden in den Selektionsbildern vorausgewählt. Wir wählen alle Optionen aus, die wir verwenden möchten.

Wenn wir die Optionen für unsere Ports in Zukunft neu konfigurieren möchten, können wir den obigen Befehl mit der Option -c erneut ausführen. Dadurch werden uns alle verfügbaren Konfigurationsoptionen angezeigt, unabhängig davon, ob wir in der Vergangenheit eine Auswahl getroffen haben:

poudriere options -c -j 12-0x64 -p HEAD -f /usr/local/etc/poudriere.d/port-list

Die Ports bauen

Jetzt sind wir endlich bereit, mit dem Aufbau von Ports zu beginnen.

Wir geben Folgendes ein, um die Jail zu aktualisieren:

poudriere jail -u -j 12-0x64

Anschließend geben wir Folgendes ein, um die Ports-Struktur zu aktualisieren:

poudriere ports -u -p HEAD

Sobald dies abgeschlossen ist, können wir den Build-Prozess starten.

Hinweis: Dies kann ein sehr langer Prozess sein. Wenn wir über SSH mit dem Server verbunden sind, wir empfehlen, das screen Paket zu installieren und eine Sitzung zu starten:

pkg install screen
 
rehash
  
screen

Um den Build zu starten, müssen wir nur den Befehl bulk verwenden und auf alle unsere einzelnen Teile zeigen, die wir konfiguriert haben. Wenn wir die Werte in diesem Handbuch verwendet haben, sieht der Befehl folgendermaßen aus:

poudriere bulk -j 12-0x64 -p HEAD -f /usr/local/etc/poudriere.d/port-list

Dies startet eine Reihe von Arbeitern (abhängig von unserer poudriere.conf-Datei oder der Anzahl der verfügbaren CPUs) und beginnt mit dem Aufbau der Ports.

Während des Erstellungsprozesses können wir jederzeit Informationen über den Fortschritt erhalten, indem wir die STRG-Taste gedrückt halten und t drücken.

Bestimmte Teile des Prozesses produzieren mehr Output als andere.

Einrichten von NGINX für das Bereitstellen des Frontends und des Repositorys

Für diesen Schritt muss der NGINX mit Virtualhosts eingerichtet sein.

In der /etc/hosts wird der folgende Hostname eingetragen: 127.0.0.1 bsd.«domain»

Damit Poudriere unter NGINX läuft, wird unter /usr/local/etc/nginx/vhosts/ folgende Datei unter dem Namen poudriere.conf mit diesem Inhalt angelegt:

server {
  listen 80 default;
  server_name bsd.><domain>>;
  root /usr/local/share/poudriere/html;
           
  location /data {
    alias /usr/local/poudriere/data/logs/bulk;
    autoindex on;                    
  }
           
  location /packages {
    root /usr/local/poudriere/data;
    autoindex on;                    
  }        
}

Anschließend den NGINX neu starten:

service nginx restart

Als Nächstes werden wir eine kleine Änderung an unserer mime.types-Datei vornehmen. Wenn wir bei den aktuellen Einstellungen auf ein Protokoll im Webbrowser klicken, wird die Datei heruntergeladen und nicht als normaler Text angezeigt. Wir können dieses Verhalten ändern, indem wir Dateien mit der Endung .log als Nur-Text-Dateien markieren.

Öffnen Sie die Datei mime.types in Ihrem Texteditor:

nano /usr/local/etc/nginx/mime.types

Wir suchen den Eintrag, der den text / plain-Inhaltstyp angibt, und hängen das Protokoll an das Ende der aktuellen Liste der Dateitypen an, getrennt durch ein Leerzeichen:

text/mathml                         mml;
text/plain                          txt log;
text/vnd.sun.j2me.app-descriptor    jad;

Jetzt können wir das Poudriere-Webinterface anzeigen, indem wir in unserem Webbrowser zum Domain-Namen oder zur IP-Adresse unseres Servers gehen bsd.«domain»

Paket-Clients konfigurieren

Nachdem wir nun Pakete erstellt und ein Repository für die Bereitstellung Ihrer Pakete konfiguriert haben, können wir unsere Clients so konfigurieren, dass sie unseren Server als Paket-Quelle verwenden.

Konfigurieren des Build-Servers für die Verwendung des eigenen Paket-Repos

Wir können damit beginnen, den Build-Server so zu konfigurieren, dass er die Pakete verwendet, die er erstellt hat.

Zuerst müssen wir ein Verzeichnis für unsere Repository-Konfigurationsdateien erstellen:

mkdir -p /usr/local/etc/pkg/repos

In diesem Verzeichnis können wir unsere Repository-Konfigurationsdatei erstellen. Es muss in .conf enden, daher werden wir es poudriere.conf nennen, um seinen Zweck zu verdeutlichen:

nano /usr/local/etc/pkg/repos/poudriere.conf =>
 
poudriere: {
  url: "file:///usr/local/poudriere/data/packages/12-0x64-HEAD",
  mirror_type: "srv",
  signature_type: "pubkey",
  pubkey: "/usr/local/etc/ssl/certs/poudriere.cert",
  enabled: yes,
  priority: 100                          
}

Wenn wir nur Pakete auswählen, die wir selbst erstellt haben (die sicherere Route), können wir die Prioritätseinstellung weglassen, aber wir sollten die Standard-Repositorys deaktivieren. Wir können dies tun, indem wir eine andere Repo-Datei erstellen, die die Standard-Repository-Datei überschreibt und sie deaktiviert:

nano /usr/local/etc/pkg/repos/freebsd.conf => 
 
FreeBSD: {
  enabled: no      
}

Unabhängig von unserer Konfigurationsauswahl sollten wir jetzt bereit sein, unser Repository zu verwenden. Wir aktualisieren unsere Paketliste, indem wir Folgendes eingeben:

pkg update

Jetzt kann unser Server den Befehl pkg verwenden, um Pakete von unserem lokalen Repository zu installieren.

Konfigurieren von Remote-Clients für die Verwendung des Repository Ihres Build-Rechners

Einer der überzeugendsten Gründe, Poudriere auf einer Build-Maschine einzurichten, besteht darin, diesen Host als Repository für viele andere Maschinen zu verwenden. Alles, was wir tun müssen, um dies zum Laufen zu bringen, ist das Herunterladen des öffentlichen SSL-Zertifikats von unserer Build-Maschine und das Einrichten einer ähnlichen Repository-Definition.

Um von unseren Client-Computern aus eine Verbindung mit unserem Build-Host herzustellen, sollten wir einen SSH-Agenten auf unserem lokalen Computer starten, um unsere SSH-Schlüsselanmeldeinformationen zu speichern.

Wir müssen unseren SSH-Schlüssel hinzufügen, indem wir Folgendes eingeben:

ssh-add

Anschließend können wir unseren lokalen SSH-Anmeldeinformationen an unseren Client Computer weiterleiten, wenn wir die Verbindung mit dem -A-Flag herstellen. Auf diese Weise können wir von unserem Client Computer aus auf einen beliebigen Computer zugreifen, als ob wir von unserem Heimcomputer darauf zugreifen würden:

ssh -A freebsd@client_domain_or_IP

Sobald wir uns auf unserem Remote-Client-Rechner befinden, müssen wir zuerst die Verzeichnisstruktur erstellen (falls diese nicht existiert), damit wir das Zertifikat speichern können. Wir werden weitermachen und ein Verzeichnis für Schlüssel erstellen, damit wir es für zukünftige Aufgaben verwenden können:

mkdir -p /usr/local/etc/ssl/{keys,certs}

Jetzt können wir uns mit SSH mit unserer Build-Maschine verbinden und die Zertifikatsdatei an unseren Client-Rechner zurückleiten. Da wir unsere SSH-Zugangsdaten weitergeleitet haben, sollten wir dies tun können, ohne ein Passwort anzufordern:

ssh user@server_domain_or_IP 'cat /usr/local/etc/ssl/certs/poudriere.cert' | tee /usr/local/etc/ssl/certs/poudriere.cert

Dieser Befehl stellt mithilfe unserer lokalen SSH-Anmeldeinformationen eine Verbindung zur Build-Maschine von unserem Client Computer her. Sobald die Verbindung hergestellt ist, zeigt sie den Inhalt Ihrer Zertifikatsdatei an und leitet uns durch den SSH-Tunnel zurück zu unserem Remote-Client-Rechner. Von dort verwenden wir die tee Kombination, um das Zertifikat in unser Verzeichnis zu schreiben.

Sobald dies abgeschlossen ist, können wir unsere Repository-Verzeichnisstruktur wie auf dem Build-Rechner selbst erstellen:

mkdir -p /usr/local/etc/pkg/repos

Jetzt können wir eine Repository-Datei erstellen, die der auf der Build-Maschine verwendeten ähnlich ist:

nano /usr/local/etc/pkg/repos/poudriere.conf =>
 
poudriere: {
  url: "http://server_domain_or_IP/packages/12-0x64-HEAD/",
  mirror_type: "http",
  signature_type: "pubkey",
  pubkey: "/usr/local/etc/ssl/certs/poudriere.cert",
  enabled: yes,
  priority: 100
}

Wenn wir nur unsere kompilierten Pakete verwenden möchten, sollte die Datei in etwa so aussehen:

poudriere: {
  url: "http://server_domain_or_IP/packages/12-0x64-HEAD/",
  mirror_type: "http",
  signature_type: "pubkey",
  pubkey: "/usr/local/etc/ssl/certs/poudriere.cert",
  enabled: yes
}

Wenn wir nur eigene Pakete verwenden wollen, müssen wir daran denken, eine andere Repository-Konfigurationsdatei zu erstellen, um die standardmäßige FreeBSD-Repository-Konfiguration zu überschreiben:

nano /usr/local/etc/pkg/repos/freebsd.conf => 
 
FreeBSD: {
  enabled: no
}

Nachdem wir fertig sind, aktualisieren wir unsere pkg-Datenbank, um mit der Verwendung unserer benutzerdefinierten kompilierten Pakete zu beginnen:

pkg update

Cronjob

Damit Poudriere automatisch die Jails aktualisiert und die Pakete baut werden wir einen Cronjob einrichten.

Wir erstellen folgende Datei unter /usr/local/etc/poudriere.d/scripts:

mkdir /usr/local/etc/poudriere.d/scripts
 
nano /usr/local/etc/poudriere.d/scripts/poudriere-cron.sh =>

#!/bin/sh

SCRIPTNAME=`basename "$0"`

# check for running script
STATUS=`ps ax | grep "$SCRIPTNAME" | grep -v grep | wc -l`

# compare to 2 because the ` create a sub process
if [ "$STATUS" -gt 2 ]; then
  echo "already running ... exit"
  exit 0
fi


# The build
POUDRIERE="/usr/local/bin/poudriere"
PORTLIST="/usr/local/etc/poudriere.d/port-list"

JAILS="12amd64"
REPOS="HEAD 2018Q3"
SETS="base openssl libressl"
#SETS="base"

URL="https://bsd.<<domain>>"

poudriere_build() {
  for SET in $SETS; do
    for JAIL in $JAILS; do
      for REPO in $REPOS; do
        echo "Started $JAIL / $REPO / $SET ("`/bin/date | /usr/bin/tr -d '\n'`")"
        "$POUDRIERE" bulk -j "$JAIL" -z "$SET" -p "$REPO"  -f "$PORTLIST" > /dev/null
        echo "    Cleaning $REPO ("`/bin/date | /usr/bin/tr -d '\n'`")"
        "$POUDRIERE" pkgclean -j "$JAIL" -z "$SET" -p "$REPO" -f "$PORTLIST" -y > /dev/null
        echo "    Finished $REPO ("`/bin/date | /usr/bin/tr -d '\n'`")"
      done
    done
  done
}

repos_update() {
  echo "[$SCRIPTNAME] Updating ports tree..."

  for REPO in $REPOS; do
    echo "[$SCRIPTNAME] Updating ports tree... $REPO"
    "$POUDRIERE" ports -p "$REPO" -u > /dev/null
    
    if [ $? -ne 0 ]; then
      echo "    Error updating ports tree."
      exit 1
    fi
  
  echo "    Ports tree has been updated."
  done
}

echo "This is a log of poudriere. Details: $URL"
echo ""

repos_update
poudriere_build

echo "[$SCRIPTNAME] Cleaning distfiles..."
"$POUDRIERE" distclean -p "$REPOS" -f "$PORTLIST" -y > /dev/null

echo "[$SCRIPTNAME] Finished. ("`/bin/date | /usr/bin/tr -d '\n'`")"

exit 0

Anschließend ausführbar machen:

chmod +x /usr/local/etc/poudriere.d/scripts/poudriere-cron.sh

Dannach sollten wir das Script einmal ausführen, um zu testen, ob alles korrekt läuft.

Wenn alles passt, können wir es in der /etc/crontab wie folgt einbinden:

nano /etc/crontab => 
 
10      0       *       *       *       root    /usr/local/etc/poudriere.d/scripts/poudriere-cron.sh

Der Build-Prozess wird dann jede Nacht ausgeführt. Wenn wir Pakete haben, wie zum Beispiel Chromium, wo der Build länger braucht als 24 Stunden, kann es hier angepasst werden.

Befehlsliste

Poudriere make.conf

nano /usr/local/etc/poudriere.d/make.conf

Poudriere conf

nano /usr/local/etc/poudriere.conf

Portlist

nano  /usr/local/etc/poudriere.d/port-list

Eine neue Jail erstellen

poudriere jail -c -j 12-0x64 -v 12.0-RELEASE

Eine Jail aktualisieren

poudriere jail -u -j 12-0x64

Ports aktualisieren

poudriere ports -u -p HEAD

Unbenutze Pakete entfernen

poudriere pkgclean -j 12-0x64 -p HEAD -f /usr/local/etc/poudriere.d/port-list

Optionen für die Portliste setzen

poudriere options -c -j 12-0x64 -p HEAD -f /usr/local/etc/poudriere.d/port-list

Optionen für ein Paket setzen

poudriere options -c -j 12-0x64 -p HEAD  databases/mariadb103-client

Pakete ohne cronjob bauen

poudriere bulk -j 12-0x64 -p HEAD -f /usr/local/etc/poudriere.d/port-list

Bei einem Systemupgrade die Options auf die neue Version kopieren

cp -R /usr/local/etc/poudriere.d/11-2x64-HEAD-options/**.* /usr/local/etc/poudriere.d/12-0x64-HEAD-options/