m158/docs/wings/README.md

# Realisieren: Wings

## Inhaltsverzeichnis

- [Inhaltsverzeichnis](#inhaltsverzeichnis)
- [Setup VM](#setup-vm)
  - [Proxmox ID und IP Format](#proxmox-id-und-ip-format)
- [Installation Wings](#installation-wings)
  - [Dependencies](#dependencies)
  - [Wings Installation](#wings-installation)
  - [Wings Configuration](#wings-configuration)
  - [Daemonizing](#daemonizing)

## Setup VM

Als allererstes müssen wir eine VM für Wings erstellen, da alle Server hier drauf laufen werden.

Diese VM sollte im Idealfall genug Ressourcen für so viele Server haben, wie auch auf dem letzten Server gelaufen sind.<br>
Das wird im Kapitel [Planen](../README.md#serverressourcen) behandelt.

![create vm in proxmox](../../assets/wings/create-vm-1.png)

Zuerst definieren wir eine ID. Da habe ich (Stelian) eine strikte Definition und Gruppierung, die auch die IP Adresse bestimmt. Hostname ist `wings`.

### Proxmox ID und IP Format

| Service Category | ID Format | IP Address      |
| ---------------- | --------- | --------------- |
| Miscellaneous    | `9TXX`    | `10.1.9T.XX/16` |

```txt
9TXX  ==>  9120  ==>  10.1.91.20/16
  ^ X steht für die Ziffer der VM/des CTs.
 ^ T steht für den Typ der Ressource, also Container oder VM (0 oder 1 respektive)
^ 9 ist die Category-ID, davon hat es einige mehr
```

![choose iso for vm](../../assets/wings/create-vm-2.png)

Als Betriebssystem wählen wir Ubuntu 24.04 LTS, da das die neueste Ubuntu Server LTS Version ist, und meine prefferierte Wahl für VMs ist, und auch von Pterodactyl unterstützt wird.

![create virtual qcow2 drive](../../assets/wings/create-vm-4.png)

Als VHD kreiren wir eine 128 GB grosse Harddisk, damit alle jetzigen (und zukünftigen) Gameserver platz finden.

![4 cores for the system](../../assets/wings/create-vm-5.png)

Das System kriegt 4 Threads (oder vCores) von den 8 verfügbaren, nutzt aber nicht zu jeder Zeit alle.

![32GB of RAM](../../assets/wings/create-vm-6.png)

Wie [hier](../README.md#serverressourcen) schon erwähnt, kann diese VM 32 GB auf meinem System besetzen. Würde der Server in Zukunft mehr benötigen, kann ich entweder einige Gameserver stoppen, oder mehr RAM in den Host einbauen.

![network vmbr1 for LAN](../../assets/wings/create-vm-7.png)

Hier wähle ich eins meiner zwei Netzwerkbridges auf meinem System.

| Bridge  | Network                    |
| ------- | -------------------------- |
| `vmbr0` | WAN und Static IPs         |
| `vmbr1` | LAN, `10.1.0.0/16` Subnetz |

Container und VMs, die eine statische IPv4 haben, kriegen `vmbr0` als Netzwerkinterface. Das erlaubt ihnen mit der jetzigen Konfiguration, direkt ins Internet zu sprechen.

Wings setzen wir aber erstmals ins LAN Subnetz, also `vmbr1`, da wir momentan keine statische IP benötigen. Wir können später mit Caddy einen Port von Aussen zum Minecraft Server zum Testen weiterleiten.

In einer Produktionsumgebung wäre es ein Nice-to-Have eine statische IPv4 für diese Minecraft Server zu besitzen, damit sowas nicht nötig ist.

![creation summary](../../assets/wings/create-vm-8.png)

So sieht die finale VM nun also aus.

## Installation Wings

Nach einer kurzen Installation von Ubuntu auf dem Server kann man schon mit der Installation von Wings beginnen.<br>
Hierfür gehe ich genau wie in [dieser](https://pterodactyl.io/wings/1.0/installing.html) Dokumentation beschrieben vor.

### Dependencies

Docker ist bereits auf der VM installiert, da ich die VM anch Ubuntu's Installation mit [dieser](https://gitpot.org/lunivity/ansible-core/src/branch/main/roles/docker/tasks/main.yml) Ansible Rolle initialisiert habe. Ansonsten kann man Docker auch mit folgendem Command leicht installieren:

```bash
# install docker using their official script
$ curl -sSL https://get.docker.com/ | CHANNEL=stable bash
```

### Wings Installation

Um `wings` zu installieren, führen wir einfach folgende Commands aus:

```bash
# create wings directory
$ sudo mkdir -p /etc/pterodactyl

# download wings binary
$ curl -L -o /usr/local/bin/wings "https://github.com/pterodactyl/wings/releases/latest/download/wings_linux_$([[ "$(uname -m)" == "x86_64" ]] && echo "amd64" || echo "arm64")"

# set the wings binary to be executable
$ sudo chmod u+x /usr/local/bin/wings
```

### Wings Configuration

Jetzt müssen wir zurück ins Panel um eine `wings` Konfiguration zu erstellen. Das können wir unter `Admin Panel -> Nodes -> Create New`

![create node](../../assets/wings/create-node.png)

Hier tippen wir die *interne IP Adresse* vom Nest-Host ein. Das machen wir so, weil Nest am Besten mit einer dedizierten IP Adresse läuft.<br>
Wir haben bereits jegliche Konfigurationen (hinter Reverse Proxy, hinter Reverse Proxy über HTTP, etc.), aber keine schien gut zu funktionieren (je nach Konfiguration an verschiedenen Punkten keine Verbindung mehr zum Host).

Sobald wir auf 'Save Changes' klicken, gibt uns das eine Konfiguration, die in etwa so aussieht:

```yml
debug: false
uuid: <redacted>
token_id: <redacted>
token: <redacted>
api:
  host: 0.0.0.0
  port: 2080
  ssl:
    enabled: false
    cert: /etc/letsencrypt/live/10.1.91.20/fullchain.pem
    key: /etc/letsencrypt/live/10.1.91.20/privkey.pem
  upload_limit: 100
system:
  data: /var/lib/pterodactyl/volumes
  sftp:
    bind_port: 2022
allowed_mounts: []
remote: 'http://nugget.sangelo.space'
```

Diese Konfiguration machen wir in `/etc/pterodactyl/config.yml` auf dem Wings Server und starten diesen dann mit `sudo wings --debug` zum Testen der Verbindung.

![node health](../../assets/wings/node-health.png)

Sobald Wings läuft, sehen wir im About Tab, dass die Verbindung erfolgreich ist. Das kann man an der erkannten Daemon Version und an den korrekten Systeminformationen erkennen.

Jetzt können wir das Backend auch daemonizen.

### Daemonizing

Daemonizing bedeutet, das Programm in einen Dienst umzuwandeln. Unter Ubuntu macht man das mit Systemd, welches .service-Dateien als Anweisungen nimmt. Der Inhalt dieser Datei ist bei jeder Wings-Installation gleich, also kann man sie einfach aus der Anleitung kopieren:

```ini
[Unit]
Description=Pterodactyl Wings Daemon
After=docker.service
Requires=docker.service
PartOf=docker.service

[Service]
User=root
WorkingDirectory=/etc/pterodactyl
LimitNOFILE=4096
PIDFile=/var/run/wings/daemon.pid
ExecStart=/usr/local/bin/wings
Restart=on-failure
StartLimitInterval=180
StartLimitBurst=30
RestartSec=5s

[Install]
WantedBy=multi-user.target
```

In dieser Datei wird grob gesagt definiert, mit welchem User welches Programm ausgeführt werden soll. Es hat noch einige Parameter mehr wie zum Beispiel die Restart Policy und die Startintervalle.

Wenn man diese Datei nun unter `/etc/systemd/system` als `wings.service` speichert, kann man den Dienst mit dem Befehl `systemctl enable --now wings` aktivieren und auch gleich starten.<br>
Bevor dieser Befehl aber verfügbar ist, muss der SystemD-Daemon reloaded werden mit `systemctl daemon-reload`.

```bash
$ systemctl enable --now wings.service; systemctl status wings.service

● wings.service - Pterodactyl Wings Daemon
     Loaded: loaded (/etc/systemd/system/wings.service; enabled; preset: enabled)
     Active: active (running) since Tue 2024-07-09 20:42:33 UTC; 3s ago
   Main PID: 24459 (wings)
      Tasks: 9 (limit: 35772)
     Memory: 10.2M (peak: 11.0M)
        CPU: 55ms
     CGroup: /system.slice/wings.service
             └─24459 /usr/local/bin/wings

Jul 09 20:42:33 wings wings[24459]:  INFO: [Jul  9 20:42:33.207] checking for pterodactyl system us>
Jul 09 20:42:33 wings wings[24459]:  INFO: [Jul  9 20:42:33.207] configured system user successfull>
Jul 09 20:42:33 wings wings[24459]:  INFO: [Jul  9 20:42:33.209] fetching list of servers from API
Jul 09 20:42:33 wings wings[24459]:  INFO: [Jul  9 20:42:33.469] processing servers returned by the>
Jul 09 20:42:33 wings wings[24459]:  INFO: [Jul  9 20:42:33.469] finished processing server configu>
Jul 09 20:42:33 wings wings[24459]:  INFO: [Jul  9 20:42:33.471] configuring system crons  interval>
Jul 09 20:42:33 wings wings[24459]:  INFO: [Jul  9 20:42:33.471] starting cron processes   subsyste>
Jul 09 20:42:33 wings wings[24459]:  INFO: [Jul  9 20:42:33.472] configuring internal webserver hos>
Jul 09 20:42:33 wings wings[24459]:  INFO: [Jul  9 20:42:33.472] updating server states on Panel: m>
Jul 09 20:42:33 wings wings[24459]:  INFO: [Jul  9 20:42:33.473] sftp server listening for connecti>
```