Linux Container (LXC) auf Raspberry Pi

class: center, middle

# Linux Container (LXC)
## auf Raspberry Pi
### Hauke Goos-Habermann
#### https://goos-habermann.de
---

### Über mich

- Entwickler des <a href="https://m23.sourceforge.io">Softwareverteilungssystems m23</a>

- Organisator der <a href="https://kielux.de">Kieler Open Source und Linux Tage</a>

- <a href="https://goos-habermann.de/">Dienstleister zu m23, Linux und Freier Software</a>

- Softwareentwicklung (PHP, BASH, C/C++, JS, Python und was sonst so gebraucht wird...)
  - Administration
  - Schulungen
  - Support
  - Beratung
  - quasi **alles**, *was mit Linux zu tun hat*

- Wöchentlicher Livestream *"Jean und Hauke Show"* auf https://www.youtube.com/c/LinuxGuides

- Community-Video-Serie *"Nicht der Weisheit letzter Schluß"* auf <a href="https://tube.tchncs.de/c/ndwls">tube.tchncs.de</a> und <a href="https://www.youtube.com/channel/UCNDn2bb2AHVCliErAwA-45g">YouTube</a> mit **beruflichen** oder **privaten Projekten**

- Probiert hin und wieder aus, was man noch mit dem Raspberry Pi anstellen kann.
---

### Abonniert Haukes Kanal!
![img80](ndwls-logo.png)

Hier gibt es Videos zu **beruflichen** und **privaten Projekten** aus dem Linux- und OpenSource-Bereich.

⇓⇓⇓ <a href="https://weisheit.goos-habermann.de">Links stehen unten in der Videobeschreibung.</a> ⇓⇓⇓
---

### Was ist LXC (**L**inu**x** **C**ontainers)?

* **Simuliert** eine virtuelle Umgebung, die Linux-Distributionen **vorgaukelt**, allein auf einem System zu laufen

* Ist **ähnlich** wie Docker **keine Vollvirtualisierung**, sondern quasi eine chroot-Umgebung mit Abschottung der Containerprozesse durch Kernelnamensräume, cgroups, AppArmor, etc.

* Alle LXC-Container **teilen** sich denselben **Host-Kernel**

* LXC-Container sind auf **"langfristige" Nutzung** ausgelegt

* LXC-Container werden (normalerweise) aus einem **Template** der jeweiligen **Distribution** erstellt

* **Daten** sind immer **persistent**

* **Aktualisierungen** laufen über die **Paketverwaltung** der Distribution, die im jeweiligen Container läuft

https://de.wikipedia.org/wiki/LXC
---

### LXC-fähiges OS holen

* Raspberry Pi OS (32-Bit) **funktioniert**, ist aber eben nur 32-Bit

* Raspberry Pi OS (64-Bit) **fehlt** ein Kernel, der die nötigen Funktionen (z.B. veth-Modul) bereitstellt

* Debian 11 für ARM64 **funktioniert**

* SD-Kartenabbilder werden bei Debian täglich gebaut
	* **Getestete** gibt es unter https://raspi.debian.net/tested-images
	* Z.B. https://raspi.debian.net/tested/20220121_raspi_4_bullseye.img.xz
	* Schreiben z.B. mit

```bash
xzcat -d 20220121_raspi_4_bullseye.img.xz | dd bs=1M of=/dev/sdX
```

---

### Software installieren

```bash
# System aktualisieren
apt-get update
apt-get -y dist-upgrade

# Software installieren
apt-get -y install lxc man libvirt0 libpam-cgfs bridge-utils uidmap acl\
 screen resolvconf

# Überprüfen, ob das System LXC kann
lxc-checkconfig
```

#### Alternativen GPG-Schlüsselserver immer verwenden

LXC überprüft standardmäßig die GPG-Signaturen der LCX-Templates. Dabei versucht LXC den öffentlichen Teil des GPG-Schlüssels von einem nicht funktionierenden Server zu holen. Daher wird ein anderer konfiguriert:

```bash
echo 'export DOWNLOAD_KEYSERVER="keyserver.ubuntu.com"'\
 > /etc/profile.d/download_keyserver.sh
```

---

### Grundlagen

```bash
# Liste mit Templates holen, herunterladen und Container bauen
lxc-create -n test1 -t download

# Nur Container für arm64 auflisten
lxc-create -t download -n test1 -- -a arm64

# Container (im Hintergrund) starten
lxc-start test1

# Container (im Vordergrund) starten
lxc-start test1 -F

# Mit Containerconsole verbinden
lxc-attach test1

# Container stoppen
lxc-stop test1

# Containerübersicht
lxc-ls -f
```
---

### Ein Debian-Container

```bash
# Template herunterladen und Container anlegen
lxc-create -t download -n debian11 -- -a arm64 -d debian -r bullseye

# Container starten und verbinden
lxc-start debian11
lxc-attach debian11
```

#### SSH: Debian, Ubuntu & Devuan
Standardmäßig sind bei den Templates weder ein SSH-Server installiert, noch ein root-Paßwort gesetzt oder ein Benutzer angelegt. Daher (bei Bedarf) nachholen:

```bash
# SSH-Server installieren
apt update && apt -y install openssh-server

# Benutzer "test" anlegen
/usr/sbin/adduser test

# root-Paßwort setzen
passwd

# Für Ubuntu: Zur sudo-Gruppe hinzufügen
/usr/sbin/adduser test sudo
```
---

### Ein AlmaLinux-Container

```bash
# Template herunterladen und Container anlegen
lxc-create -t download -n alma1 -- --dist=almalinux --release=8 --arch=arm64

# Container starten und verbinden
lxc-start alma1
lxc-attach alma1
```

#### SSH: AlmaLinux, CentOS, Fedora, Rocky Linux & Oracle Linux
Standardmäßig sind bei den Templates weder ein SSH-Server installiert, noch ein root-Paßwort gesetzt oder ein Benutzer angelegt. Daher (bei Bedarf) nachholen:
```bash
# SSH-Server installieren
dnf install -y less openssh-server openssh-clients

# SSH-Server jetzt und beim Booten starten
systemctl start sshd && systemctl enable sshd

# Benutzer "test" anlegen und root-Paßwort setzen
/sbin/useradd test && passwd test; passwd
```
---

### Ein OpenSUSE-Tumbleweed-Container

```bash
# Template herunterladen und Container anlegen
lxc-create -t download -n tumbleweed -- -a arm64 -d opensuse -r tumbleweed

# Container starten und verbinden
lxc-start tumbleweed
lxc-attach tumbleweed
```

#### SSH: OpenSUSE
Standardmäßig sind bei den Templates weder ein SSH-Server installiert, noch ein root-Paßwort gesetzt oder ein Benutzer angelegt. Daher (bei Bedarf) nachholen:
```bash
# Pakete nachinstallieren und SSHd starten
zypper in yast2-users yast2 yast2-trans-de openssh-server less
systemctl start sshd
systemctl enable sshd

# Benutzer "test" anlegen und root-Paßwort setzen
useradd test && passwd test; passwd
```
---

### SSH-Zugriff

**Auf dem Host** können die dynamischen IPs der laufenden ermittelt werden mit
```bash
lxc-ls -f
```

SSH-Verbindung **vom Host** zum Container (privates NAT-Netzwerk)
```bash
ssh test@10.0.x.y
```

SSH-Port des Containers (22) auf dem Port 8022 des Hosts verfügbar machen, damit andere Rechner innerhalb des Netzwerkes (indirekt) mit dem Container kommunizieren können:
```bash
iptables -t nat -p tcp -I PREROUTING --dport 8022 -j DNAT --to 10.0.x.y:22
iptables -A FORWARD -p tcp --dport 22 -j ACCEPT
```
---

### Netzwerkbrücke

Über eine Netzwerkbrücke können die Container eine **eigene IP** innerhalb des normalen Netzwerkes bekommen. Diese IPs kommunizieren alle über die Netzwerkkarte des Hosts.

Dazu die */etc/network/interfaces* des Hosts (mit statischer IP-Konfiguration) von links nach rechts anpassen:

![img80](bridge-konfig-diff.png)

Danch einen Neustart machen und die neue Konfiguration bewundern:
```bash
reboot
ip a
```
---

### Konfiguration
#### Netzwerkbrücke: Kopiervorlage

```bash
auto lxcbr0
allow-hotplug lxcbr0
iface lxcbr0 inet static
	address 192.168.1.122
	netmask 255.255.255.0
	network 192.168.1.0
	broadcast 192.168.1.255
	gateway 192.168.1.5
	dns-nameservers 192.168.1.5
	bridge_ports eth0
	bridge_fd 0
	bridge_maxwait 0
```

#### DNS
```bash
systemctl stop systemd-resolved.service
systemctl disable systemd-resolved.service
rm /etc/resolv.conf
echo "nameserver 192.168.1.5" > /etc/resolv.conf
```
---

### Statische IP für Container

**Bei jedem Start** eines Containers wird diesem eine **neue IP** innerhalb des privaten NAT-Netzwerkes zugewiesen. Den Containern können aber (teilweise) statische IPs zugewiesen werden, indem Ihr z.B. in */var/lib/lxc/alma1/config* folgendes anhängt:

```bash
# Statische Netzwerkkonfiguration
lxc.net.0.ipv4.address = 192.168.1.184/24
lxc.net.0.ipv4.gateway = 192.168.1.5
```

Hinweis: Nicht jedes Distributionstemplate unterstützt eine solche Konfiguration.

Testergebnis:

* AlmaLinux ✓
* Ubuntu 22.04 ✓
* Debian 11 😢

Wenn es nicht funktioniert, könnt Ihr versuchen, die IP innerhalb des Containers zu setzen.
---

### Sicherheitserwägungen

* Sicherheitslage ähnliche wie bei **Docker**, da grundliegende Technologie gleich ist

* **Priviligierte** Container laufen mit **root-Rechten**, **unpriviligierte** unter den Rechten eines **normalen Benutzers**

* Wenn möglich, **unpriviligierte Container** verwenden,
	* da der **root-Benutzer** innerhalb eines Containers mit dem des Hosts identisch ist
	* da **Gruppen-** und **Benutzernummern** ansonsten **identisch** zum Hostsystem sind
	* da bei einem **Ausbruch** leichter **root-Rechte** auf dem Host zu erlangen sind

* **Vorsicht** beim **Mounten von Host-Verzeichnissen** in den Container. Besser nur im Nur-Lesen-Modus einbinden.

Mehr dazu: https://wiki.gentoo.org/wiki/LXC#Security_concerns
---

### LXC als unpriviligierter Nutzer

```bash
#### Als root ####

# Benutzer anlegen und das Ausführen von langlaufenden Sitzungen
# ermöglichen, die auch nach Abmeldung weiterlaufen
adduser test
loginctl enable-linger test

# test den Zugriff auf die (virtuelle) Netzwerkkarte gestatten
echo test veth lxcbr0 10 >> /etc/lxc/lxc-usernet

#### Als Benutzer "test" ####

# Verzeichnisse anlegen
mkdir -p ~/.config/lxc ~/.local/share

# Benutzer-/Gruppennummernabbildung und AppArmor konfigurieren
echo 'lxc.include = /etc/lxc/default.conf
lxc.idmap = u 0 100000 65536
lxc.idmap = g 0 100000 65536
lxc.apparmor.profile = lxc-container-default-cgns' > ~/.config/lxc/default.conf

# ACLs setzen
cd ~; setfacl --modify user:100000:x . .local .local/share
```
---

### LXC als unpriviligierter Nutzer

Die Konfigurationsdatei befindet sich unter ~/.local/share/lxc/*[Containername]*/config

```bash
# Template herunterladen und Container anlegen
lxc-create -t download -n ubuntu -- --dist=ubuntu --release=jammy --arch=arm64

# Statische IP setzen
echo 'lxc.net.0.ipv4.address = 192.168.1.222/24
lxc.net.0.ipv4.gateway = 192.168.1.5' >> ~/.local/share/lxc/ubuntu/config

# Starten
screen -dmS ubuntu lxc-unpriv-start -n ubuntu -F

# Containerübersicht
lxc-ls -f

# Verbinden
lxc-unpriv-attach ubuntu

# Container stoppen
lxc-stop ubuntu
```
---

### Snapshots

Das Anlegen und Wiederherstellen von Snapshots funktioniert nur, wenn ein Container heruntergefahren ist.

```bash
# Liste der vorhandenen Snapshots eines Containers
lxc-snapshot -n test1 -L

# Anlegen
lxc-snapshot -n test1

# Snapshot im selben Container wiederherstellen
lxc-snapshot -n test1 -r snap0

# Neuen Container aus Snapshot bauen
lxc-snapshot -n test1 -r snap0 -N neuercontainer
```
---

### Weiteres

#### Seiten mit nützlichen Informationen
* https://wiki.debian.org/LXC
* https://wiki.archlinux.org/title/Linux_Containers
* https://wiki.gentoo.org/wiki/LXC

#### Noch mehr Möglichkeiten

* Autostart von Containern
* Zwischen Host und Container geteilte Verzeichnisse
* Quotas für CPU, Ram, etc. einrichten
* Desktop installieren und mit Fernzugriffssoftware nutzen
* XOrg-Programme laufen lassen
* Eigene Templates erstellen
* ...

evtl. demnächst auf **Nicht der Weisheit letzter Schluß** :-)

⇓⇓⇓ <a href="https://weisheit.goos-habermann.de">Links stehen unten in der Videobeschreibung.</a> ⇓⇓⇓
---

### Abonniert Haukes Kanal!
![img80](ndwls-logo.png)

Hier gibt es Videos zu **beruflichen** und **privaten Projekten** aus dem Linux- und OpenSource-Bereich.

⇓⇓⇓ <a href="https://weisheit.goos-habermann.de">Links stehen unten in der Videobeschreibung.</a> ⇓⇓⇓
---

class: center, middle
### Informationen zu mir und meinen Dienstleistungen, m23, ...
### https://goos-habermann.de