pot ist ein weiterer Jail-Manager für FreeBSD. In dem Artikel möchte ich dir zeigen, wie du das Tool zum Laufen bringst und deine erste grundlegende Jail mit pot erstellst. In der Vergangenheit habe ich bereits sehr viel über Bastille geschrieben.

Attention: For the english version, click here!

Ähnlich wie Bastille wurde pot in Shell geschrieben und bedarf daher nur wenig Speicherplatz. Der Download samt Abhängigkeiten beträgt circa 7 MB und auf der Festplatte werden circa 35 MB beansprucht. Voraussetzung ist, es wird ZFS als Dateisystem benötigt und du benötigst root-Zugriff auf deinem System. Ist das gegeben, kannst du direkt die Software installieren.

Installation von pot

Wie immer, solltest du zuerst dein Repository updaten:

pkg update 

Danach können wir auch schon den Jail-Manager installieren:

pkg install pot

Nach der erfolgreichen Installation weist uns pot darauf hin, zunächst die Initalisierung durchzuführen. Das geschieht durch folgenden Befehl:

pot init

Die erste Jail erstellen

Im Prinzip ist pot genau so benutzerfriendlich, wie andere Jail-Manager. Mittels dem Befehl pot create kannst du die erste Jail erstellen. Stell vorher am Besten sicher, dass du root-Zugriff auf deinem System hast.

pot create [-hv] -p potname [-N network-type] [-i ipaddr]
           [-l lvl] [-f flavour] [-b base|-P basepot]
           [-d dns] [-t type]
  -h print this help
  -v verbose
  -k keep the pot, if create fails
  -p potname : the pot name (mandatory)
  -l lvl : pot level (only for type multi)
  -b base : the base pot
  -P pot : the pot to be used as reference
  -d dns : pot dns resolver configuration, one of
           inherit*       - inherit from jailhost (*default)
           pot            - the pot configured in POT_DNS_NAME
           custom:<file>  - copy <file> into pot configuration
           off            - leave resolver config unaltered
  -f flavour : flavour to be used
  -t type: pot file system layout, one of
           single         - the pot is based on a unique ZFS dataset
           multi*         - the pot is composed by a classical
                            collection of 3 ZFS datasets (*default)
  -N network-type: pot network layout, one of
           inherit*       - inherit the host network stack (*default)
           alias          - configure a static ip alias directly on
                            the host's NIC
           public-bridge  - use the common internal public bridge
           private-bridge - use an internal private bridge (with -B)
  -i ipaddr : IP address selection, one of
           auto*          - automatically assign address (*default),
                            only works with (public|private)-bridge
           ipaddr         - mandatory with alias,
                            also works with (public|private)-bridge
  -B bridge-name : the name of the private bridge to be used
  -S network-stack : the network stack (ipv4, ipv6 or dual)

Das Menü bietet alles, was man braucht und ist dabei schlank und übersichtlich.

pot create -p meineBox -b 13.2 -d inherit -t single -N alias -i 192.168.0.10 -S ipv4

Hiermit erstellst du eine Jail mit folgenden Eigenschaften:

• -p: Der Name lautet meineBox
• -b: Das Basesystem basiert auf FreeBSD 13.2
• -d: Es soll der DNS-Server des Hostsystems verwendet werden
• -t: Es wird ein ZFS dataset verwendet
• -N: Es wird ein Alias direkt auf die Netzwerkkarte des Hostsystems gesetzt
• -i: Die IP der Jail lautet 192.168.0.10
• -S: Es wird ausschließlich IPv4 verwendet

Nach einer Weile hast du deine erste Jail mit pot erstellt. Der Output sollte ungefähr so aussehen:

root@byte-sized:/home/mitarbyter # pot create -p meineBox -b 13.2 -d inherit -t single -N alias -i 192.168.0.10 -S ipv4
===>  Creating a new pot
===>  pot name     : meineBox
===>  type         : single
===>  base         : 13.2
===>  pot_base     :
===>  level        : 0
===>  network-type : alias
===>  network-stack: ipv4
===>  ip           : 192.168.0.10
===>  bridge       :
===>  dns          : inherit
===>  flavours     :
===>  Fetching FreeBSD 13.2
===>  Extract the tarball

Jetzt kannst du direkt in deine Jail wechseln, nutze dafür folgenden Befehl:

root@byte-sized:/home/mitarbyter # pot run meineBox
===>  Starting the pot meineBox
ELF ldconfig path: /lib /usr/lib /usr/lib/compat
32-bit compatibility ldconfig path: /usr/lib32
Updating motd:.
Creating and/or trimming log files.
Clearing /tmp (X related).
Updating /var/run/os-release done.
Starting syslogd.
Starting sendmail_submit.
Starting sendmail_msp_queue.
Starting cron.

Wed Aug 30 21:23:59 UTC 2023


root@meineBox:~ #

Hierbei wird die Jail gestartet und du springst direkt in deinen angelegten Container. Dies erkennst du am Command Prompt. Bei mir lautet dieser jetzt root@meineBox. Nun kannst du dich innerhalb deiner Jail frei bewegen, Software installieren und beginnen sie weiter zu konfigurieren.

Wenn du deine Jail wieder verlassen möchtest, tippe einfach exit und du landest wieder auf deinem Hostsystem.

Willst du deinen Container irgendwann wieder löschen, verwende folgendes Kommando:

pot destroy -p meineBox

Fazit

Das soll der Schnelleinstieg zu pot gewesen sein. In naher Zukunft werde ich bestimmt noch öfters darüber schreiben, da ich persönlich pot für recht interessant halte. Im direkten Vergleich zu Bastille, mit dem ich sehr gerne gearbeitet habe, scheint mir die Erstellung von Containern mit pot tatsächlich noch einfacher. Nachteil ist allerdings, dass reine Linux-Jails aktuell nicht möglich sind, was wiederrum für Bastille spricht. Es kommt also, wie so oft, ganz auf das Einsatzgebiet an.

---

pot – Another Jail Manager for FreeBSD

pot is another jail manager for FreeBSD. In the article I want to show you how to get the tool working and create your first basic jail with pot. In the past I have written a lot about Bastille. Similar to Bastille, pot is written in shell and therefore requires very little memory. The download including dependencies is about 7 MB and on disk about 35 MB. Prerequisite is that you need ZFS as file system and root access on your system. If this is given, you can install the software directly.

Installing pot

As always, you should update your repository first:

pkg update

After that we can install the jail manager:

pkg install pot

After the successful installation pot tells us to do the initialization first. This is done by the following command:

pot init

Create the first jail

In principle, pot is as user-friendly as other jail managers. You can create the first jail using the pot create command. Make sure you have root access to your system before you create the jail.

pot create [-hv] -p potname [-N network-type] [-i ipaddr]
           [-l lvl] [-f flavour] [-b base|-P basepot]
           [-d dns] [-t type]
  -h print this help
  -v verbose
  -k keep the pot, if create fails
  -p potname : the pot name (mandatory)
  -l lvl : pot level (only for type multi)
  -b base : the base pot
  -P pot : the pot to be used as reference
  -d dns : pot dns resolver configuration, one of
           inherit*       - inherit from jailhost (*default)
           pot            - the pot configured in POT_DNS_NAME
           custom:<file>  - copy <file> into pot configuration
           off            - leave resolver config unaltered
  -f flavour : flavour to be used
  -t type: pot file system layout, one of
           single         - the pot is based on a unique ZFS dataset
           multi*         - the pot is composed by a classical
                            collection of 3 ZFS datasets (*default)
  -N network-type: pot network layout, one of
           inherit*       - inherit the host network stack (*default)
           alias          - configure a static ip alias directly on
                            the host's NIC
           public-bridge  - use the common internal public bridge
           private-bridge - use an internal private bridge (with -B)
  -i ipaddr : IP address selection, one of
           auto*          - automatically assign address (*default),
                            only works with (public|private)-bridge
           ipaddr         - mandatory with alias,
                            also works with (public|private)-bridge
  -B bridge-name : the name of the private bridge to be used
  -S network-stack : the network stack (ipv4, ipv6 or dual)

The menu offers everything you need and is lean and clear.

pot create -p myBox -b 13.2 -d inherit -t single -N alias -i 192.168.0.10 -S ipv4

With this you create a jail with the following properties:

• -p: The name is myBox
• -b: The base system is based on FreeBSD 13.2.
• -d: The DNS server of the host system will be used.
• -t: A ZFS dataset will be used.
• -N: An alias is set directly to the network card of the host system
• -i: The IP of the jail is 192.168.0.10
• -S: Only IPv4 is used

After a while you have created your first jail with pot. The output should look something like this:

root@byte-sized:/home/mitarbyter # pot create -p meineBox -b 13.2 -d inherit -t single -N alias -i 192.168.0.10 -S ipv4
===>  Creating a new pot
===>  pot name     : meineBox
===>  type         : single
===>  base         : 13.2
===>  pot_base     :
===>  level        : 0
===>  network-type : alias
===>  network-stack: ipv4
===>  ip           : 192.168.0.10
===>  bridge       :
===>  dns          : inherit
===>  flavours     :
===>  Fetching FreeBSD 13.2
===>  Extract the tarball

Now you can switch directly to your jail, use the following command:

root@byte-sized:/home/mitarbyter # pot run meineBox
===>  Starting the pot meineBox
ELF ldconfig path: /lib /usr/lib /usr/lib/compat
32-bit compatibility ldconfig path: /usr/lib32
Updating motd:.
Creating and/or trimming log files.
Clearing /tmp (X related).
Updating /var/run/os-release done.
Starting syslogd.
Starting sendmail_submit.
Starting sendmail_msp_queue.
Starting cron.

Wed Aug 30 21:23:59 UTC 2023


root@meineBox:~ #

Here the jail is started and you jump directly into your created container. You can recognize this by the command prompt. For me this is now root@myBox. Now you can move freely within your jail, install software and start configuring it.

If you want to leave your jail again, just type exit and you will end up back on your host system.

If you want to delete your container at some point, use the following command:

pot destroy -p myBox

Conclusion

This should be the quick introduction to pot. In the near future I will certainly write more about it, because I personally think pot is quite interesting. In direct comparison to Bastille, which I really liked to work with, it seems to be even easier to create containers with pot. The disadvantage, however, is that pure Linux jails are currently not possible, which speaks for Bastille. So, as often, it all depends on the use case.