# Hermes Agent auf einem VPS einrichten: 24/7 Linux-Server-Guide

Beim Betrieb des Hermes Agent auf einem VPS läuft das Open-Source-Agentenframework dauerhaft auf einem Linux-Server statt auf dem eigenen Computer. Dadurch ist der Agent rund um die Uhr erreichbar, kann schnell auf externe Modell- und Tool-APIs zugreifen und zeitgesteuerte Aufgaben über integrierte Cron-Automatisierungen selbstständig ausführen.

## Was bedeutet der Betrieb des Hermes Agent auf einem VPS?

Den [Hermes Agent](https://www.ionos.at/digitalguide/server/knowhow/was-ist-hermes-agent/) auf einem [VPS](https://www.ionos.at/digitalguide/server/knowhow/was-ist-ein-virtual-private-server-vps/) zu betreiben bedeutet, das [Open-Source](https://www.ionos.at/digitalguide/server/knowhow/was-ist-open-source/)-Agentenframework von Nous Research auf einem **dauerhaft erreichbaren Linux-Server zu installieren**. Dadurch bleibt der [KI-Agent](https://www.ionos.at/digitalguide/websites/web-entwicklung/ki-agenten/) unabhängig vom eigenen Computer verfügbar, kann Modell- und Tool-[APIs](https://www.ionos.at/digitalguide/websites/web-entwicklung/was-ist-eine-api/) mit geringer Netzwerklatenz ansprechen und zeitgesteuerte Aufgaben über seinen integrierten Cron- und Gateway-Prozess selbstständig ausführen. Ein Virtual Private Server ist besonders für Messenger-Bots, regelmäßige Rechercheaufgaben, Webhooks und andere Automatisierungen, die rund um die Uhr erreichbar sein sollen, eine sinnvolle Wahl.

## VPS-Systemvoraussetzungen und Betriebssystem

Für den normalen VPS-Betrieb muss das verwendete [Sprachmodell](https://www.ionos.at/digitalguide/server/knowhow/large-language-model/) **nicht** auf dem Server selbst laufen. Hermes kann beispielsweise über OpenRouter, Anthropic, Nous Portal, Google/Gemini oder andere unterstützte Anbieter auf ein extern gehostetes Modell zugreifen. In diesem Fall verarbeitet der VPS vor allem die Hermes-Anwendung, Sitzungsdaten, Gateway-Verbindungen, [Cronjobs](https://www.ionos.at/digitalguide/hosting/hosting-technik/cronjob/) und lokale Werkzeuge.

Die folgenden Werte sind deshalb praktische Empfehlungen für den API-Betrieb und keine starren, vom Programm erzwungenen Hardwaregrenzen:

<table>
  <thead>
    <tr>
      <th><strong>Komponente</strong></th>
      <th><strong>Minimum (nur API)</strong></th>
      <th><strong>Empfohlen (für lokale Tools/Docker)</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Prozessor</td>
      <td>1 vCPU</td>
      <td>2 bis 4 vCPUs</td>
    </tr>
    <tr>
      <td>Arbeitsspeicher</td>
      <td>2 GB RAM</td>
      <td>4 bis 8 GB RAM</td>
    </tr>
    <tr>
      <td>Speicherplatz</td>
      <td>20 GB SSD oder NVMe</td>
      <td>50 GB oder mehr</td>
    </tr>
    <tr>
      <td>Systemarchitektur</td>
      <td>64-Bit, beispielsweise x86-64 oder ARM64</td>
      <td>x86-64 für größtmögliche Kompatibilität</td>
    </tr>
    <tr>
      <td>Netzwerk</td>
      <td>Stabile Internetverbindung mit ausgehendem HTTPS-Zugriff</td>
      <td>Hohe Bandbreite und niedrige Latenz</td>
    </tr>
    <tr>
      <td>Betriebssystem</td>
      <td>Ubuntu 24.04 LTS oder 26.04 LTS</td>
      <td>Ubuntu 24.04 LTS oder 26.04 LTS</td>
    </tr>
    <tr>
      <td>Zusätzlicher Swap-Speicher</td>
      <td>1 GB bei knappem RAM sinnvoll</td>
      <td>2 bis 4 GB als Reserve</td>
    </tr>
  </tbody>
</table>

Die Tabelle bezieht sich ausdrücklich auf den Betrieb **mit externen Modell-APIs**. Ein großes Sprachmodell lokal auf einem gewöhnlichen [CPU](https://www.ionos.at/digitalguide/server/knowhow/cpu/)-VPS auszuführen, erfordert erheblich mehr Arbeitsspeicher und Rechenleistung. Für größere lokale Modelle sind normalerweise ein GPU-Server oder speziell dafür ausgelegte Hardware notwendig.

Hinweis Nicht nur der Server, sondern **auch das gewählte Sprachmodell** muss zu Hermes passen. Nach der Hermes-Dokumentation benötigt das Modell ein Kontextfenster von mindestens 64.000 [Tokens](https://www.ionos.at/digitalguide/websites/web-entwicklung/ai-token/). Kleinere Kontextfenster reichen für längere Werkzeugabläufe und umfangreiche Sitzungen nicht aus und können beim Start abgelehnt werden. Bei einem Anbieter wie OpenRouter oder Anthropic wählen Sie daher ein Modell mit mindestens 64K-Kontextfenster.

## Server-Härtung und Sicherheitsvorkehrungen

Hermes kann Dateien bearbeiten, Programme ausführen und Terminal-Befehle starten. Ein unsicher konfigurierter VPS würde Angreifenden dadurch besonders weitreichende Möglichkeiten bieten. Sie sollten den Agenten deshalb **niemals dauerhaft als Root-User** betreiben und nur diejenigen Funktionen, Ports und Zugänge aktivieren, die Sie tatsächlich benötigen.

### System aktualisieren

Melden Sie sich zunächst über [SSH](https://www.ionos.at/digitalguide/server/tools/secure-shell-ssh/) beim Server an. Bei einem neu eingerichteten VPS geschieht dies häufig zunächst als Root-User:

```bash
ssh root@SERVER-IP
```

Ersetzen Sie `SERVER-IP` durch die öffentliche [IP-Adresse](https://www.ionos.at/digitalguide/server/knowhow/was-ist-eine-ip-adresse/) Ihres Servers. Aktualisieren Sie anschließend die Paketlisten und die installierten Pakete:

```bash
apt update
apt full-upgrade -y
```

Falls dabei ein neuer Kernel installiert wurde, starten Sie den Server neu:

```bash
reboot
```

Warten Sie, bis der VPS wieder erreichbar ist, und melden Sie sich erneut an.

### Dedizierten Non-Root-User anlegen

Erstellen Sie nun einen separaten User für Hermes:

```bash
adduser hermes
```

Sie werden aufgefordert, ein sicheres Passwort zu vergeben. Weitere Angaben wie Name oder Telefonnummer können Sie mit der Eingabetaste überspringen. Fügen Sie den User anschließend der Gruppe `sudo` hinzu:

```bash
usermod -aG sudo hermes
```

Der User arbeitet damit im Alltag ohne Root-Rechte, kann aber einzelne Verwaltungsbefehle bewusst mit `sudo` ausführen. Noch strenger wäre ein Dienstbenutzer ohne allgemeine sudo-Rechte. Die offizielle Hermes-Installation unterstützt einen solchen unprivilegierten Betrieb ebenfalls; lediglich bestimmte Systembibliotheken für die Browser-Automatisierung müssen gegebenenfalls einmalig durch den Admin installiert werden.

### Anmeldung mit einem SSH-Schlüssel einrichten

SSH-Schlüssel sind **sicherer als eine reine Passwortanmeldung**. Falls auf Ihrem lokalen Computer noch kein Schlüssel vorhanden ist, erzeugen Sie dort einen Schlüssel mit dem Ed25519-Verfahren:

```bash
ssh-keygen -t ed25519
```

Übertragen Sie den öffentlichen Schlüssel anschließend auf den Server:

```bash
ssh-copy-id hermes@SERVER-IP
```

Öffnen Sie danach ein zweites Terminal und testen Sie die neue Anmeldung:

```bash
ssh hermes@SERVER-IP
```

Deaktivieren Sie den Root-Zugang erst, nachdem diese Anmeldung zuverlässig funktioniert. Andernfalls könnten Sie sich selbst aus dem Server aussperren.

### SSH-Root-Login deaktivieren

Erstellen Sie für die eigenen Einstellungen eine separate Konfigurationsdatei:

```bash
sudo nano /etc/ssh/sshd_config.d/99-hermes-hardening.conf
```

Tragen Sie Folgendes ein:

```txt
PermitRootLogin no
PubkeyAuthentication yes
PasswordAuthentication no
KbdInteractiveAuthentication no
```

Speichern Sie die Datei mit `Strg + O`, bestätigen Sie mit der Eingabetaste und schließen Sie den Editor mit `Strg + X`. Prüfen Sie die Konfiguration:

```bash
sudo sshd -t
```

Erscheint keine Fehlermeldung, können Sie den SSH-Dienst neu starten:

```bash
sudo systemctl restart ssh.service
```

Lassen Sie die bisherige SSH-Sitzung zunächst geöffnet. Testen Sie in einem zweiten Terminal erneut, ob die Anmeldung als Benutzer `hermes` funktioniert.

### UFW-Firewall konfigurieren

Ubuntu stellt mit UFW eine vergleichsweise einfach zu bedienende lokale [Firewall](https://www.ionos.at/digitalguide/server/sicherheit/was-ist-eine-firewall/) bereit. UFW ist zunächst deaktiviert und muss nach dem Anlegen der benötigten Regeln ausdrücklich eingeschaltet werden. Installieren und konfigurieren Sie UFW:

```bash
sudo apt install -y ufw
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 22/tcp
```

Port 22 wird für SSH benötigt. Falls Sie einen anderen SSH-Port verwenden, müssen Sie stattdessen diesen Port freigeben. Für öffentlich erreichbare [HTTPS](https://www.ionos.at/digitalguide/hosting/hosting-technik/was-ist-https/)-Webhooks oder einen vorgeschalteten Webserver können Sie zusätzlich die Ports 80 und 443 öffnen:

```bash
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
```

Aktivieren Sie die Firewall anschließend:

```bash
sudo ufw enable
sudo ufw status verbose
```

### Hermes selbst einschränken

Hermes verfügt über **mehrere interne Sicherheitsstufen**. Dazu gehören Benutzerfreigaben für Messaging-Plattformen, Rückfragen vor gefährlichen Befehlen, Dateischutz, Container-Isolierung und konfigurierbare Sperrregeln. Für einen unbeaufsichtigten Serverbetrieb sollten Sie insbesondere die Schutzfunktion gegen festgefahrene Werkzeugschleifen aktivieren. Öffnen Sie dazu die Hermes-Konfiguration:

```bash
nano ~/.hermes/config.yaml
```

Ergänzen Sie folgenden Block:

```txt
tool_loop_guardrails:
    hard_stop_enabled: true
    hard_stop_after:
        exact_failure: 5
        idempotent_no_progress: 5
```

Damit wird ein Ablauf **beendet**, wenn derselbe Fehler oder eine wirkungslose Aktion mehrfach wiederholt wird. Bei unbeaufsichtigten Gateway- und Cron-Sessions aktiviert Hermes solche Hard Stops bereits standardmäßig. Mit `hard_stop_enabled: true` wird die Schutzfunktion zusätzlich für alle Ausführungsumgebungen aktiviert.

## Hermes Agent mit Docker installieren

Es gibt verschiedene Wege, einen Hermes Agenten zu installieren. Sie können den [Hermes Agenten lokal betreiben](https://www.ionos.at/digitalguide/server/konfiguration/hermes-agent-lokal-betreiben/) oder auf eine [Docker](https://www.ionos.at/digitalguide/server/knowhow/was-ist-docker/)-Installation zurückgreifen. Docker kapselt Hermes vom restlichen Host-System ab. Dadurch lassen sich Abhängigkeiten, Updates und Datenverzeichnisse sauberer voneinander trennen. Das offizielle Image speichert Konfigurationen, API-Schlüssel, Sitzungen, Skills und Erinnerungen in einem vom Host eingebundenen Verzeichnis. Das eigentliche Container-Image bleibt zustandslos und kann aktualisiert werden, ohne diese Daten zu löschen.

### Schritt 1: Docker Engine unter Ubuntu installieren

Richten Sie zunächst das offizielle Docker-Paketarchiv ein:

```bash
sudo apt update
sudo apt install -y ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg \
    -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
```

Fügen Sie anschließend die Paketquelle hinzu:

```bash
sudo tee /etc/apt/sources.list.d/docker.sources > /dev/null <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF
```

Installieren Sie Docker:

```bash
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io \
    docker-buildx-plugin docker-compose-plugin
```

Prüfen Sie den Dienst:

```bash
sudo systemctl status docker
```

Testen Sie die Installation:

```bash
sudo docker run --rm hello-world
```

### Schritt 2: Hermes-Konfiguration im Container anlegen

Erstellen Sie zunächst das dauerhafte Datenverzeichnis:

```bash
mkdir -p ~/.hermes
```

Starten Sie danach einmalig den interaktiven Einrichtungsassistenten:

```bash
sudo docker run -it --rm \
    -v "$HOME/.hermes:/opt/data" \
    nousresearch/hermes-agent setup
```

### Schritt 3: Gateway dauerhaft starten

Wenn Sie [Hermes über Telegram](https://www.ionos.at/digitalguide/server/konfiguration/hermes-agent-mit-telegram-verbinden/), Discord oder eine andere Plattform mit ausgehender Gateway-Verbindung verwenden, benötigen Sie normalerweise keine veröffentlichte API-Schnittstelle:

```bash
sudo docker run -d \
    --name hermes \
    --restart unless-stopped \
    -v "$HOME/.hermes:/opt/data" \
    nousresearch/hermes-agent gateway run
```

Die Restart-Policy `unless-stopped` startet den Container nach einem Absturz oder Neustart des Docker-Dienstes erneut, sofern Sie ihn nicht zuvor bewusst gestoppt haben. Das aktuelle offizielle Hermes-Image überwacht den Gateway-Prozess zusätzlich innerhalb des Containers. Stürzt der Prozess ab, wird er nach kurzer Zeit neu gestartet, ohne dass der gesamte Container beendet werden muss.

Für Browser-Automatisierungen ergänzen Sie Shared Memory:

```bash
sudo docker run -d \
    --name hermes \
    --restart unless-stopped \
    --shm-size=1g \
    -v "$HOME/.hermes:/opt/data" \
    nousresearch/hermes-agent gateway run
```

## Persistenz im Hintergrund und Health-Check

Eine normale Anwendung, die Sie direkt in einer SSH-Sitzung starten, wird beendet, sobald die Verbindung geschlossen wird. Für den dauerhaften Betrieb benötigt Hermes deshalb entweder einen systemd-Dienst oder einen Docker-Container mit Restart-Policy.

### Native Installation mit systemd betreiben

Hermes kann die passende systemd-Service-Datei selbst erzeugen. Das ist **zuverlässiger als eine manuell kopierte Vorlage**, weil der Installer dabei den tatsächlichen User, das Hermes-Verzeichnis und den richtigen Pfad zur virtuellen Python-Umgebung berücksichtigt.

Richten Sie zunächst die gewünschten Messaging-Plattformen ein:

```bash
hermes gateway setup
```

Installieren Sie den Gateway als systemweiten Dienst:

```bash
sudo hermes gateway install --system
```

Starten Sie den Dienst:

```bash
sudo hermes gateway start --system
```

Prüfen Sie seinen Zustand:

```bash
sudo hermes gateway status --system
```

Die laufenden Protokolle sehen Sie mit:

```bash
sudo journalctl -u hermes-gateway -f
```

Der systemweite Dienst eignet sich besonders für VPS- und Headless-Systeme, die nach einem Neustart zuverlässig hochfahren sollen. Installieren Sie nicht gleichzeitig einen Benutzer- und einen Systemdienst, da sonst unklar werden kann, welche Instanz durch die Hermes-Befehle verwaltet wird.

### Installation mit Hermes Doctor prüfen

Prüfen Sie zum Abschluss die Hermes-Installation und -Konfiguration:

```bash
hermes doctor
```

Der Diagnosebefehl überprüft die wichtigsten Komponenten des Setups und weist auf mögliche Konfigurationsprobleme hin. Beheben Sie gemeldete kritische Fehler, bevor Sie Hermes dauerhaft im Hintergrund betreiben.

## Hermes Agent auf einem IONOS VPS einrichten

Die allgemeine Anleitung lässt sich beispielsweise auf einem IONOS VPS mit Ubuntu 24.04 LTS umsetzen. Bei IONOS verwalten Sie Ihre VPS-Produkte über das Cloud Panel.

### Schritt 1: Passenden IONOS VPS auswählen

Die IONOS-VPS+-Tarife unterscheiden sich vor allem durch CPU-Kerne, RAM und NVMe-Speicher:

<table>
  <thead>
    <tr>
      <th><strong>Szenario</strong></th>
      <th><strong>Passender Tarif</strong></th>
      <th><strong>Begründung</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Einfacher Telegram- oder Discord-Bot mit externer Modell-API</td>
      <td>VPS S+ mit 2 vCores, 2 GB RAM und 90 GB NVMe</td>
      <td>Ausreichend für einen einzelnen, schlank konfigurierten Gateway ohne Browser-Automatisierung</td>
    </tr>
    <tr>
      <td>Allgemeiner 24/7-Betrieb mit Docker und mehreren Cron-Aufgaben</td>
      <td>VPS M+ mit 4 vCores, 4 GB RAM und 120 GB NVMe</td>
      <td>Gute Standardausstattung mit Reserve für Updates, Logs und mehrere Integrationen</td>
    </tr>
    <tr>
      <td>Browser-Automatisierung, mehrere Profile oder parallele Aufgaben</td>
      <td>VPS L+ mit 6 vCores, 8 GB RAM und 240 GB NVMe</td>
      <td>Genügend RAM für Chromium, Docker und mehrere gleichzeitige Prozesse</td>
    </tr>
    <tr>
      <td>Viele parallele Agenten und umfangreiche Tool-Workloads</td>
      <td>VPS XL+ mit 8 vCores, 16 GB RAM und 480 GB NVMe</td>
      <td>Mehr Reserve für parallele Browser- und Codeprozesse</td>
    </tr>
  </tbody>
</table>

Für die meisten Einsteigerinnen und Einsteiger ist der VPS M+ die ausgewogenste Wahl. Der VPS S+ kann für einen einzelnen API-basierten Bot genügen, lässt aber nur **wenig Spielraum** für Browser, zusätzliche Container oder mehrere gleichzeitig laufende Aufgaben.

### Schritt 2: VPS bereitstellen und Zugangsdaten aufrufen

Bestellen Sie den gewünschten VPS und wählen Sie Ubuntu 24.04 LTS als Betriebssystem. Öffnen Sie danach in Ihrem IONOS-Konto den Bereich „Menü“ → „Server &amp; Cloud“. Wählen Sie unter „Infrastruktur“ → „Server“ den neuen VPS aus. In den Serverdetails finden Sie den Hostnamen beziehungsweise die IP-Adresse, den anfänglichen User und das Initial-Passwort.

[![Bild: VPS im IONOS Cloud Panel](https://www.ionos.at/digitalguide/fileadmin/_processed_/2/4/csm_cloudpanel-server-daten_1b10063ab4.webp "VPS im IONOS Cloud Panel")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/cloudpanel-server-daten.jpg) IONOS Cloud Panel mit den Serverdetails. Stellen Sie von Ihrem lokalen Computer die erste Verbindung her:

```bash
ssh root@SERVER-IP
```

Die SSH-Verbindung ist verschlüsselt. IONOS beschreibt sie als regulären Verwaltungsweg für Linux-Server.

Führen Sie danach die bereits beschriebenen Schritte durch:

1. Aktualisieren Sie Ubuntu.
2. Legen Sie den User `hermes` an.
3. Übertragen Sie einen SSH-Schlüssel.
4. Testen Sie den neuen Zugang.
5. Deaktivieren Sie den Root-Login.
6. Installieren Sie Hermes nativ oder mit Docker.

### Schritt 3: Externe IONOS-Firewall konfigurieren

Neben UFW besitzt der IONOS VPS eine externe Firewall, die im Cloud Panel verwaltet wird. Beide Firewalls sollten aufeinander abgestimmt sein. Ein Port muss nur dann in beiden Ebenen geöffnet werden, wenn er tatsächlich von außen erreichbar sein soll.

Öffnen Sie im Cloud Panel den Bereich „Netzwerk“ → „Firewall-Richtlinien“. Wählen Sie die dem Server zugewiesene Richtlinie aus und entfernen Sie alle nicht benötigten Freigaben. Für eine einfache Hermes-Installation genügen normalerweise:

<table>
  <thead>
    <tr>
      <th><strong>Erlaubte IP</strong></th>
      <th><strong>Protokoll</strong></th>
      <th><strong>Port</strong></th>
      <th><strong>Beschreibung</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Eigene feste IP oder alle IPs, falls unvermeidbar</td>
      <td>TCP</td>
      <td>22</td>
      <td>SSH</td>
    </tr>
    <tr>
      <td>Alle IPs</td>
      <td>TCP</td>
      <td>80</td>
      <td>Optional für HTTP und Zertifikate</td>
    </tr>
    <tr>
      <td>Alle IPs</td>
      <td>TCP</td>
      <td>443</td>
      <td>Optional für HTTPS-Webhooks</td>
    </tr>
  </tbody>
</table>

Port 8642 und Port 9119 sollten **nicht direkt in der IONOS-Firewall** geöffnet werden. Verwenden Sie für Verwaltungszugriffe besser einen SSH-Tunnel oder einen korrekt abgesicherten [Reverse Proxy](https://www.ionos.at/digitalguide/server/knowhow/was-ist-ein-reverse-proxy/).

[![Bild: Firewall-Richtlinien im IONOS Cloud Panel](https://www.ionos.at/digitalguide/fileadmin/_processed_/d/2/csm_cloudpanel-firewall-richtlinien_ef12f7f1c6.webp "Firewall-Richtlinien im IONOS Cloud Panel")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/cloudpanel-firewall-richtlinien.jpg) IONOS-Firewall-Richtlinie mit freigegebenem SSH- und HTTPS-Port für Hermes Agent.  Hinweis Für reine Telegram-, Discord- oder andere Messenger-Gateways müssen Sie keinen Port des Containers veröffentlichen. Port 8642 wird nur benötigt, wenn Sie den API-Server beziehungsweise dessen Health-Endpunkt vom Host aus erreichen möchten. Veröffentlichen Sie den Port daher nur, wenn Sie diese Funktion tatsächlich nutzen.

### Schritt 4: Hermes auf dem IONOS VPS installieren

Melden Sie sich nun als neuer User an:

```bash
ssh hermes@SERVER-IP
```

Installieren Sie die Basispakete:

```bash
sudo apt update
sudo apt install -y git curl xz-utils ca-certificates
```

Führen Sie anschließend den Hermes-Installer aus:

```bash
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
source ~/.bashrc
```

Starten Sie die Einrichtung:

```bash
hermes setup
```

Wählen Sie Ihren Modellanbieter, tragen Sie den API-Schlüssel ein und aktivieren Sie nur die Werkzeuge und Messaging-Plattformen, die Sie benötigen.

[![Bild: Hermes Setup im Terminal](https://www.ionos.at/digitalguide/fileadmin/_processed_/4/2/csm_hermes-setup_0e9e05ee1a.webp "Hermes Setup im Terminal")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/hermes-setup.jpg) Einrichtungsassistent des Hermes Agent auf einem IONOS Ubuntu VPS. Prüfen Sie zunächst einen normalen Chat:

```bash
hermes
```

[![Bild: Chat mit dem Hermes Agenten](https://www.ionos.at/digitalguide/fileadmin/_processed_/3/7/csm_hermes-agent-chat_77503ae12c.webp "Chat mit dem Hermes Agenten")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/hermes-agent-chat.jpg) Wenn der Chat mit dem Hermes Agenten funktioniert, ist der erste Schritt getan. Richten Sie erst danach den dauerhaften Gateway ein:

```bash
hermes gateway setup
sudo hermes gateway install --system
sudo hermes gateway start --system
```

Führen Sie zum Abschluss die Diagnose aus:

```bash
hermes doctor
sudo hermes gateway status --system
```

[![Bild: Status des Hermes Agenten](https://www.ionos.at/digitalguide/fileadmin/_processed_/3/8/csm_hermes-agent-status_289722ccce.webp "Status des Hermes Agenten")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/hermes-agent-status.jpg) Erfolgreiche Hermes-Doctor-Diagnose und laufender Gateway-Dienst auf einem IONOS VPS. ### Schritt 5: 24/7-Betrieb abschließend testen

Ein erfolgreicher Status direkt nach der Installation genügt noch nicht. Starten Sie den IONOS VPS einmal kontrolliert neu:

```bash
sudo reboot
```

Melden Sie sich nach dem Neustart wieder an und prüfen Sie:

```bash
sudo hermes gateway status --system
```

Bei Docker verwenden Sie stattdessen:

```bash
sudo docker ps
sudo docker logs --tail 50 hermes
```

Senden Sie zusätzlich eine Testnachricht über die angebundene Messaging-Plattform und führen Sie eine einfache Cron-Aufgabe aus. Der Hermes-Scheduler wird vom laufenden Gateway verwaltet und prüft standardmäßig regelmäßig, ob geplante Aufgaben fällig sind. Ohne laufenden Gateway werden diese Automatisierungen nicht automatisch ausgeführt.

## Sicherheits- und Betriebscheckliste

Vor dem produktiven Betrieb sollten folgende Punkte erfüllt sein:

Hermes läuft nicht als Root-User.

Die SSH-Anmeldung funktioniert über einen Schlüssel.

Der Root-Login und die Passwortanmeldung per SSH sind deaktiviert.

Die IONOS-Firewall und UFW lassen nur erforderliche Ports zu.

Port 8642 und das Dashboard sind nicht direkt öffentlich erreichbar.

Die Datei `~/.hermes/.env` besitzt die Berechtigung `600`.

Nur freigegebene User dürfen den Messenger-Gateway ansprechen.

Die Schutzfunktion gegen wiederholte Tool-Schleifen ist aktiviert.

`hermes doctor` meldet keine kritischen Fehler.

Der Gateway startet nach einem Serverneustart automatisch.

Backups des Verzeichnisses `~/.hermes` werden regelmäßig erstellt.

Sicherheitsupdates für Ubuntu, Docker und Hermes werden regelmäßig eingespielt.

## Fazit

Ein Linux-VPS macht den Hermes Agent **unabhängig vom eigenen Computer** und ermöglicht dauerhaft erreichbare Messenger-Bots, API-Schnittstellen und zeitgesteuerte Automatisierungen. Für einen einfachen API-Betrieb reichen wenige Ressourcen, während Docker, Browser-Automatisierung und parallele Aufgaben von zusätzlichem Arbeitsspeicher profitieren.

Ein einzelner VPS bleibt trotz automatischer Neustarts ein **möglicher Ausfallpunkt**. Für geschäftskritische Anwendungen sollten Sie deshalb zusätzlich externe Backups, eine Überwachung des Health-Endpunkts und bei Bedarf eine zweite Instanz mit Load Balancer einplanen.


This is a markdown version of: [https://www.ionos.at/digitalguide/server/konfiguration/hermes-agent-vps/](https://www.ionos.at/digitalguide/server/konfiguration/hermes-agent-vps/) for AI/LLM consumption.