OpenCode mit Hetzner Experiments Inference API + systemd-Sandbox

Einführung

OpenCode ist ein KI-gestützter Coding-Agent für das Terminal. Anders als reine Chatbots arbeitet OpenCode direkt mit einem Softwareprojekt. Es kann Dateien lesen und bearbeiten, Code analysieren, Änderungen vorschlagen oder Tests durchführen sowie mit Git-Repositories arbeiten. Dadurch unterstützt es den gesamten Entwicklungsprozess, ohne dass Code in ein Chatfenster kopiert werden muss, da es direkt in der lokalen Entwicklungsumgebung arbeiten kann.

Typische Alternativen oder vergleichbare Tools sind beispielsweise:

GitHub Copilot
Cursor
Claude Code
Aider

Im Gegensatz zu vielen integrierten KI-Assistenten ist OpenCode nicht an eine bestimmte IDE oder einen bestimmten Modellanbieter gebunden.

Warum Hetzner Experiments Inference API?

OpenCode selbst stellt kein Sprachmodell bereit. Stattdessen verbindet es sich mit einem kompatiblen LLM-Anbieter.

In diesem Tutorial verwenden wir die Hetzner Experiments Inference API.

Vorteile:

europäischer Anbieter
OpenAI-kompatible API
keine lokale GPU notwendig
funktioniert direkt mit OpenCode

Warum eine Sandbox?

Ein Coding-Agent hat mehr Rechte als ein normaler Chatbot. Er kann Dateien verändern, lokale Befehle ausführen und Entwicklungswerkzeuge starten.
Das ist praktisch, aber auch ein Sicherheitsrisiko.

Die Sandbox beschränkt den Zugriff von OpenCode auf:

das aktuelle Git-Repository
die notwendigen OpenCode-Konfigurations- und Cache-Verzeichnisse

Das restliche Home-Verzeichnis wird versteckt.

Voraussetzungen

Dieses Tutorial setzt voraus:

Linux mit systemd (z. B. Ubuntu, Debian, Fedora, Arch Linux)
eine funktionierende Benutzer-Session für systemd --user
ein Git-Repository
eine Shell mit Zugriff auf ~/.bashrc

Schritt 1 - OpenCode installieren

Installiere OpenCode z.B. folgendermaßen:

curl -fsSL https://opencode.ai/install | bash

Oder verwende eine andere Installationsmethode: https://opencode.ai/docs#install

Falls der Installationspfad noch nicht in deiner aktuellen Shell bekannt ist, lade die Shell-Konfiguration neu:

source ~/.bashrc

Alternativ kannst du auch ein neues Terminal öffnen.

Prüfe anschließend, wo sich die OpenCode-Binary befindet:

which opencode

Beispiel (je nach Installationsmethode kann der Pfad abweichen):

/home/<user>/.opencode/bin/opencode

Diesen Pfad benötigst du später im Wrapper-Skript.

Schritt 2 - API-Key erstellen

Melde dich unter https://experiments.hetzner.com an.
Wähle links unter APPS "Inference" aus.
Klicke dann oben rechts auf den Button "Create API Token".

Schritt 3 - API-Key als Environment Variable ablegen

echo 'export HETZNER_VLLM_API_KEY="<Hier-deinen-Token-einfügen>"'  >> ~/.bashrc
source ~/.bashrc

Prüfe, ob die Variable gesetzt wurde:

echo "$HETZNER_VLLM_API_KEY"

Schritt 4 - OpenCode konfigurieren

mkdir -p ~/.config/opencode
vim ~/.config/opencode/opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "hetzner": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Hetzner",
      "options": {
        "baseURL": "https://inference.hetzner.com/api/v1",
        "apiKey": "{env:HETZNER_VLLM_API_KEY}"
      },
      "models": {
        "Qwen/Qwen3.6-35B-A3B-FP8": {
          "name": "Qwen3.6-35B-A3B-FP8"
        }
      }
    }
  },
  "model": "hetzner/Qwen/Qwen3.6-35B-A3B-FP8"
}

Schritt 5 - OpenCode starten

Jetzt kannst du opencode direkt starten oder mit der Sandbox-Einrichtung weitermachen, falls du opencode sicher innerhalb eines Projekts verwenden willst. In Schritt 11 findest du noch eine Jetbrains IDE Integration. Beim ersten Start sollte OpenCode das konfigurierte Modell automatisch verwenden.

Schritt 6 - Wrapper-Verzeichnis anlegen

Falls noch nicht vorhanden:

mkdir -p ~/bin

Außerdem die OpenCode-Verzeichnisse anlegen:

mkdir -p \
  ~/.config/opencode \
  ~/.local/share/opencode \
  ~/.local/state/opencode \
  ~/.cache/opencode

Schritt 7 - Sandbox-Wrapper erstellen

Erstelle:

~/bin/opencode

Passe anschließend die Variable OPENCODE_BIN an den Pfad aus which opencode an.

#!/usr/bin/env bash

OPENCODE_BIN="/home/<user>/.opencode/bin/opencode"

if [[ ! -x "$OPENCODE_BIN" ]]; then
  echo "Error: OpenCode binary not found or not executable:"
  echo "  $OPENCODE_BIN"
  echo
  echo "Run 'which opencode' and update OPENCODE_BIN in this script."
  exit 1
fi

# Find the git repository root
git_root=$(git rev-parse --show-toplevel 2>/dev/null)

if [[ -z "$git_root" ]]; then
  echo "Warning: Not in a git repository; assuming current directory"
  git_root="$(pwd)"
fi

if [[ "$git_root" = "$HOME" ]]; then
  echo "Fatal: refusing to launch from HOME, since this would expose everything."
  exit 2
fi

systemd-run --user --pty --pipe --collect \
  -p PrivateTmp=yes \
  -p ProtectHome=tmpfs \
  -p TemporaryFileSystem=$HOME \
  -p InaccessiblePaths="/run/docker /run/dbus /run/NetworkManager" \
  -p NoNewPrivileges=yes \
  -p ProtectSystem=strict \
  -p ProtectKernelTunables=yes \
  -p ProtectControlGroups=yes \
  -p BindPaths="$git_root $HOME/.config/opencode $HOME/.local/share/opencode $HOME/.local/state/opencode $HOME/.cache/opencode" \
  -p BindReadOnlyPaths="$OPENCODE_BIN $HOME/.gitconfig $HOME/.gitignore" \
  -p WorkingDirectory="$(pwd)" \
  -E SHELL=/bin/bash \
  -E PATH="$PATH" \
  -E HETZNER_VLLM_API_KEY="$HETZNER_VLLM_API_KEY" \
  -- \
  "$OPENCODE_BIN" "$@"

Dieses Skript wurde auf Basis des Artikels: https://stefansiegl.de/2026/02/sandboxing-with-systemd-run/ erstellt. Der Artikel enthält außerdem eine Variante für Nix.

Hinweis: Alle in BindPaths und BindReadOnlyPaths angegebenen Dateien und Verzeichnisse müssen existieren. Falls beispielsweise ~/.gitignore noch nicht vorhanden ist, entferne den entsprechenden Eintrag oder lege die Datei vorher an.

Schritt 8 - Wrapper ausführbar machen

chmod +x ~/bin/opencode

Schritt 9 - PATH prüfen

Der Wrapper funktioniert nur, wenn ~/bin im PATH vor dem Installationsverzeichnis von OpenCode steht. Andernfalls wird weiterhin die originale OpenCode-Binary gestartet.

Prüfe:

which opencode

Jetzt sollte erscheinen:

/home/<user>/bin/opencode

Falls weiterhin die originale Binary angezeigt wird, füge deiner ~/.bashrc folgende Zeile hinzu:

export PATH="$HOME/bin:$PATH"

Lade anschließend die Shell-Konfiguration neu:

source ~/.bashrc

Prüfe danach erneut:

which opencode

Schritt 10 - Testen

In einem Git-Repository:

opencode

Schritt 11 - Optional: Integration in JetBrains IDEs (ACP)

OpenCode kann auch direkt aus einer JetBrains IDE verwendet werden.

„AI Chat" öffnen
Drei Punkte oben rechts → „Add Custom Agent"
Folgende Konfiguration einfügen:

{
  "default_mcp_settings": {
    "use_idea_mcp": true
  },
  "agent_servers": {
    "opencode sandbox": {
      "command": "opencode",
      "args": ["acp"]
    }
  }
}

Ergebnis

In diesem Tutorial hast du OpenCode erfolgreich installiert und in einer Sandbox gestartet. Du kannst nun OpenCode direkt in deinem Projekt verwenden, ohne dass es Zugriff auf dein gesamtes Home-Verzeichnis hat.

OpenCode mit Hetzner Experiments Inference API + systemd-Sandbox

Author

Published

Time to read

Table of Contents