SSD Nodes Learn Hosting plans →
Anleitungen Matt ConnorVon Matt Connor · Aktualisiert 2026-10-30

Ollama API absichern: Anleitung gegen unbefugten Zugriff

Die Ollama-API bietet ab Werk keine Authentifizierung für Port 11434. Erfahren Sie, wie Sie den Zugriff durch Reverse Proxys oder Firewall-Regeln effektiv einschränken.

Die Ollama API hat kein Passwort

Die Ollama API verwendet keine Authentifizierung. Für eingehende Clients gibt es weder einen Benutzer noch ein Passwort oder eine Prüfung eines API key. Jeder Client, der eine TCP-Verbindung zu Port 11434 öffnen kann, kann Ihre Modelle auflisten, sie ausführen, neue Modelle herunterladen und vorhandene Modelle löschen.

Die offizielle Dokumentation formuliert es eindeutig: „Die lokale API unter http://localhost:11434 erfordert keine Authentifizierung.“ Das Wort lokal beschreibt das gesamte Sicherheitsmodell. Ollama bindet standardmäßig an 127.0.0.1. Auf einem Laptop übernimmt daher die Loopback-Schnittstelle die Zugriffskontrolle. Verlegen Sie den Listener auf eine öffentliche Adresse, entfällt diese Zugriffskontrolle, weil nichts sie ersetzt.

Deshalb ist das auf einem VPS (virtual private server) wichtig. Die Standardeinstellung ist sicher. Die erste Änderung, die viele vornehmen, besteht darin, den Listener zu öffnen, damit ein zweiter Rechner das Modell verwenden kann. Genau diese Änderung entfernt den gesamten Schutz auf einmal.

Was ein offener Port 11434 preisgibt

Jeden Endpunkt. Es gibt keinen schreibgeschützten Modus und keinen separaten Admin-Port. Dies sind die tatsächlichen Requests, die an eine Serveradresse statt an localhost gerichtet sind:

# List every model on the box
curl http://SERVER_IP:11434/api/tags

# See what is loaded into memory right now
curl http://SERVER_IP:11434/api/ps

# Run a prompt on your hardware
curl http://SERVER_IP:11434/api/generate -d '{"model":"llama3.2","prompt":"Why is the sky blue?"}'

# Write several gigabytes to your disk
curl http://SERVER_IP:11434/api/pull -d '{"model":"llama3.2"}'

# Remove a model
curl -X DELETE http://SERVER_IP:11434/api/delete -d '{"model":"llama3.2"}'

Aus Sicht des Betreibers gehen vier Dinge schief:

  • Ihre CPU oder GPU führt Inferenz für jemand anderen aus. Bei einem Tarif mit Fair-Use-Limit für CPU-Leistung wird eine dauerhafte Auslastung von einem Fremden auf Ihr Kontingent angerechnet. Die Kosten für KI-Workloads auf einem VPS unter Kontrolle zu halten wird deutlich schwieriger, sobald Sie nicht mehr der einzige Aufrufer sind.
  • /api/pull schreibt auf Ihre Festplatte. Die Modellgrößen variieren. Selbst llama3.2:1b ist 1.3 GB groß. Eine Schleife aus Pulls füllt das Volume. Ein volles Dateisystem legt jeden anderen Dienst auf dem Server lahm, nicht nur Ollama.
  • Requests erreichen Ihren Prozess und werden protokolliert. Bei der standardmäßigen Log-Stufe protokolliert Ollama nur Metadaten. Sie erhalten also den Endpunkt, den Status, die Latenz und die Clientadresse, nicht den Prompt-Text. Das ist trotzdem ein Protokoll darüber, wer Ihren Server wofür verwendet hat. Es liegt in Ihrem Journal, obwohl Sie diese Daten nicht bewusst erfassen wollten.
  • /api/delete entfernt Modelle. Um sie wiederherzustellen, müssen Sie sie über Ihre eigene Bandbreite erneut herunterladen.

Dafür ist kein Exploit erforderlich. Die dokumentierte API verhält sich genau wie vorgesehen.

Der Ed25519-Schlüssel ist keine Zugriffskontrolle

Wenn Sie nach „Ollama API key“ suchen, stoßen Sie auf zwei verschiedene Dinge. Keines davon ist ein Passwort für Ihren Server. Wenn Sie beide unterscheiden, lösen sich die meisten Unklarheiten.

Das erste ist das Identitätsschlüsselpaar. Ollama erzeugt beim ersten Start ein Ed25519-Schlüsselpaar. Unter Linux erstellt das Installationsskript einen Systembenutzer namens ollama mit seinem Home-Verzeichnis unter /usr/share/ollama. Das Schlüsselpaar liegt daher hier:

/usr/share/ollama/.ollama/id_ed25519
/usr/share/ollama/.ollama/id_ed25519.pub

Dieser Schlüssel wird für die ausgehende Authentifizierung verwendet. ollama signin registriert den öffentlichen Schlüsselteil bei Ihrem ollama.com-Konto. Er autorisiert Sie, ein Modell in die Registry zu übertragen oder ein privates Modell abzurufen. Er weist Ihre Maschine gegenüber ollama.com aus. Für Clients, die eine Verbindung zu Ihrer Maschine herstellen, wird dadurch keine Authentifizierung verlangt. Wenn Sie den Schlüssel löschen, austauschen oder nie erstellen, ändert sich nichts daran, wer Ihre API aufrufen darf.

Das zweite ist OLLAMA_API_KEY. Diese Variable enthält einen Schlüssel, den Sie unter https://ollama.com/settings/keys erstellen. Ihr Client sendet ihn als Authorization: Bearer $OLLAMA_API_KEY, wenn er die gehostete API unter https://ollama.com/api aufruft. Der Schlüssel ist eine Zugangsdaten für deren Dienst und wird von Ihnen als Client verwendet. Ihr eigenes ollama serve verwendet ihn nicht, um eingehende Anfragen zu authentifizieren. Wenn Sie OLLAMA_API_KEY auf Ihrem VPS setzen, wird dadurch kein Passwort für Ihren VPS eingerichtet.

Sie müssen daher keine Einstellung aktivieren. Die drei folgenden Schutzmaßnahmen funktionieren auf dieselbe Weise: Halten Sie den Port unerreichbar und schalten Sie einen Dienst davor, der die Anfragen tatsächlich prüft.

Prüfen, worauf Ihr Server derzeit lauscht

sudo ss -tlnp | grep 11434

Das sichere Ergebnis nennt die Loopback-Adresse:

LISTEN 0  4096  127.0.0.1:11434  0.0.0.0:*  users:(("ollama",pid=812,fd=3))

Das exponierte Ergebnis nennt jedes Interface:

LISTEN 0  4096  0.0.0.0:11434  0.0.0.0:*  users:(("ollama",pid=812,fd=3))

0.0.0.0 steht für alle IPv4-Adressen auf dem System, einschließlich der öffentlichen Adresse. *:11434 und [::]:11434 sind Wildcard-Listener auf jeder IPv6-Adresse. Ob sie auch IPv4-Verbindungen akzeptieren, hängt von der Socket-Option IPV6_V6ONLY ab, die Linux standardmäßig deaktiviert lässt (net.ipv6.bindv6only=0). Behandeln Sie daher alle drei Ergebnisse als exponiert.

Prüfen Sie dies nun von außerhalb. Führen Sie den Befehl auf Ihrem Laptop aus, nicht auf dem Server:

curl -m 5 http://YOUR_SERVER_IP:11434/api/version

curl: (28) Connection timed out after 5001 milliseconds ist das erwartete Ergebnis, ebenso curl: (7) Failed to connect ... Connection refused. Ein JSON-Objekt mit einem Feld version bedeutet, dass die gesamte API für jeden erreichbar ist, der sie abfragt. Ein Test mit curl direkt auf dem Server zeigt nicht, ob ein anderes System den Dienst erreichen kann. Wenn der Server eine IPv6-Adresse hat, wiederholen Sie den Test mit curl -6 -m 5 http://[YOUR_SERVER_IPV6]:11434/api/version gegen diese Adresse, da ein geschlossener IPv4-Port nichts über einen IPv6-Listener aussagt.

Eine Freigabe entsteht meist auf eine von zwei Arten. Die erste ist eine bewusste Änderung, weil ein zweites System das Modell erreichen musste:

sudo systemctl edit ollama.service
[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"

Diese einzelne Zeile bewirkt die vollständige Freigabe. Die zweite Möglichkeit ist Docker. Dafür müssen Sie überhaupt nichts bearbeiten. Dieser Fall wird im folgenden Abschnitt behandelt.

Abwehr 1: Auf localhost belassen und per Tunnel zugreifen

Nutzen Sie diese Option zuerst. Sie benötigt keine neue Software und erstellt keine Zugangsdaten, die nach außen gelangen können. Der Port ist auf keiner öffentlichen Schnittstelle vorhanden und kann daher nicht durch Scans gefunden werden.

Legen Sie die Bind-Adresse ausdrücklich fest, statt sich auf den Standardwert zu verlassen:

sudo systemctl edit ollama.service
[Service]
Environment="OLLAMA_HOST=127.0.0.1:11434"

Damit wird /etc/systemd/system/ollama.service.d/override.conf geschrieben. Wenden Sie die Änderung an und prüfen Sie sie:

sudo systemctl daemon-reload
sudo systemctl restart ollama
sudo ss -tlnp | grep 11434

ss sollte jetzt 127.0.0.1:11434 anzeigen. Wenn weiterhin 0.0.0.0 angezeigt wird, hat eine zweite Drop-in-Datei Vorrang. Führen Sie systemctl cat ollama.service aus, um die Unit und alle Drop-in-Dateien einschließlich ihrer Pfade aufzulisten. Löschen Sie anschließend die veraltete Datei.

Um das Modell von Ihrem Laptop aus zu verwenden, leiten Sie den Port über SSH weiter:

ssh -N -L 11434:127.0.0.1:11434 you@your-server

-L 11434:127.0.0.1:11434 öffnet Port 11434 auf Ihrem Laptop und sendet alle dort eingehenden Daten an 127.0.0.1:11434, aus Sicht des Servers. -N weist SSH an, keinen Remote-Befehl auszuführen. Der Prozess hält dadurch nur den Tunnel offen. Solange der Tunnel läuft, funktioniert Folgendes auf Ihrem Laptop:

curl -s http://localhost:11434/api/tags

Zwei Fehler werden häufig auftreten. bind [127.0.0.1]:11434: Address already in use bedeutet, dass die lokale Adresse und der lokale Port bereits verwendet werden. Ursache kann Ollama, ein anderer SSH-Tunnel oder ein anderes Programm sein. Wählen Sie daher mit -L 11500:127.0.0.1:11434 einen anderen lokalen Port und richten Sie Ihren Client auf 11500. Wenn eine Anfrage durch den Tunnel eine leere Antwort erhält, prüfen Sie ss auf dem Server und die SSH-Fehlerausgabe, bevor Sie entscheiden, welcher Dienst fehlgeschlagen ist.

Für mehrere Clientcomputer ist ein privates Netzwerk besser als ein eigener Tunnel pro Benutzer. Verbinden Sie die Computer mit WireGuard oder Tailscale. Binden Sie Ollama anschließend an die Adresse dieses Netzwerks statt an 0.0.0.0:

[Service]
Environment="OLLAMA_HOST=10.8.0.1:11434"

Der Port ist dann nur auf einer Schnittstelle vorhanden, für deren Nutzung ein kryptografischer Schlüssel erforderlich ist. Das schützt auch vor einem fehlerhaften Firewall-Regelwerk. Selbst wenn eine Regel versehentlich den gesamten Datenverkehr zulässt, kann sie keinen Listener auf einer öffentlichen Schnittstelle erreichbar machen, auf der dieser nicht gebunden ist.

Abwehr 2: Ein Reverse Proxy, der ein Bearer-Token prüft

Wenn etwas aus dem öffentlichen Internet das Modell aufrufen muss, lassen Sie Ollama auf dem Loopback-Interface und setzen Sie einen Proxy davor. Der Proxy übernimmt die TLS-Terminierung (Transport Layer Security) und weist Anfragen ohne den richtigen Header zurück. Ollama akzeptiert weiterhin nur Verbindungen von 127.0.0.1. Der Proxy ist damit der einzige Zugangsweg.

Erzeugen Sie zuerst ein echtes Token. Erfinden Sie keines von Hand:

openssl rand -base64 36

Eine nginx-Site, die das Token prüft:

map $http_authorization $ollama_ok {
    default                                   0;
    "Bearer PASTE_YOUR_GENERATED_TOKEN_HERE"  1;
}

server {
    listen 443 ssl;
    server_name llm.example.com;

    ssl_certificate     /etc/letsencrypt/live/llm.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/llm.example.com/privkey.pem;

    location = /api/pull   { return 403; }
    location = /api/delete { return 403; }
    location = /api/push   { return 403; }

    location / {
        if ($ollama_ok = 0) { return 401; }

        proxy_pass http://127.0.0.1:11434;
        proxy_set_header Host 127.0.0.1:11434;
        proxy_buffering off;
        proxy_read_timeout 600s;
    }
}

Fünf Zeilen übernehmen hier die eigentliche Arbeit. Jede davon verhindert einen Fehler, der sonst auftreten würde.

if innerhalb eines location-Blocks ist in nginx normalerweise problematisch. Ein Body mit genau return ist jedoch eine von zwei Formen, die sich vorhersehbar verhalten. Diese Verwendung ist daher sicher.

location = /api/pull ist eine exakte Übereinstimmung. nginx bewertet exakte Übereinstimmungen höher als das location /-Präfix. Daher werden diese drei Endpunkte zurückgewiesen, bevor das Token überhaupt geprüft wird. Ein gültiges Token gewährt weiterhin Zugriff auf andere Modellverwaltungsendpunkte, einschließlich /api/create und /api/blobs/:digest. Diese drei Blöcke verhindern daher nicht jeden Schreibzugriff auf die Festplatte.

proxy_set_header Host 127.0.0.1:11434; ist wichtig, weil Ollama die eingehenden Header Host und Origin untersucht. Wenn der öffentliche Hostname des Proxys unverändert weitergegeben wird, kann ein 403 Forbidden entstehen, das von Ollama statt von nginx stammt. Das erschwert die Fehlersuche. OLLAMA_ORIGINS ist der zweite Stellhebel für einen Browser-Client, der einen bestimmten Origin zulassen muss.

proxy_buffering off; ist wichtig, weil Ollama seine Antwort Token für Token streamt. Bei aktiviertem Buffering puffert nginx die Antwort, bevor es sie weiterleitet. Dadurch verzögert sich die Ausgabe der gestreamten Token.

proxy_read_timeout 600s; ist wichtig, weil nginx standardmäßig 60 Sekunden verwendet. Dieser Timer läuft zwischen zwei aufeinanderfolgenden Lesevorgängen von Ollama und nicht über die gesamte Antwort hinweg. Eine Streaming-Antwort, die fortlaufend Token erzeugt, setzt den Timer jedes Mal zurück. Sendet Ollama 60 Sekunden lang nichts, wird der Timer ausgelöst. Das kann beispielsweise bei einer Anfrage mit "stream": false geschehen, die die gesamte Antwort erst am Ende als ein Stück zurückgibt. Dasselbe gilt für eine lange Pause vor dem ersten Token. Der Client erhält 504 Gateway Time-out, und /var/log/nginx/error.log protokolliert upstream timed out (110: Connection timed out) while reading response header from upstream. Die Anfrage wurde weiterhin verarbeitet. nginx hat sie lediglich abgebrochen.

Laden Sie die Konfiguration neu und testen Sie beide Pfade:

sudo nginx -t && sudo systemctl reload nginx
curl -s -o /dev/null -w '%{http_code}\n' https://llm.example.com/api/tags
curl -s -H "Authorization: Bearer YOUR_TOKEN" https://llm.example.com/api/tags

Der erste Befehl sollte 401 ausgeben. Der zweite sollte Ihre Modellliste ausgeben. Wenn der erste Befehl ebenfalls die Modellliste zurückgibt, prüfen Sie, welcher Server und welcher Location-Block die Anfrage verarbeitet hat und ob das Neuladen erfolgreich war. Ein map-Block im falschen Gültigkeitsbereich macht die Konfiguration ungültig. Er gehört auf die Ebene http. Platzieren Sie ihn daher in einer Datei unter /etc/nginx/conf.d/ oder oberhalb des server-Blocks, niemals innerhalb von server.

Caddy erledigt dieselbe Aufgabe mit einer einfachen Authentifizierung in vier Zeilen. Das eignet sich für einen Browser-Client besser als ein Bearer-Token:

llm.example.com {
	basic_auth {
		apiuser PASTE_BCRYPT_HASH_HERE
	}
	reverse_proxy 127.0.0.1:11434
}

Führen Sie caddy hash-password aus, um den von Caddy erwarteten bcrypt-Hash zu erzeugen. Ein Hinweis zur Benennung: Vor Caddy v2.8 hieß die Direktive basicauth, jetzt heißt sie basic_auth. Caddy akzeptiert die alte Schreibweise weiterhin als veralteten Alias. Eine aus einer älteren Anleitung übernommene Konfiguration wird daher geladen. Caddy warnt jedoch, dass basicauth veraltet ist, und fordert Sie auf, stattdessen basic_auth zu verwenden. Benennen Sie die Direktive um, wenn diese Warnung angezeigt wird.

Unabhängig vom gewählten Proxy handelt es sich dabei um ein gemeinsames Geheimnis für alle. Jeder Client, der es besitzt, hat identische Zugriffsrechte. Der Widerruf erfordert Änderungen an der Konfiguration und eine gleichzeitige Aktualisierung jedes Aufrufers.

Abwehr 3: Ein Gateway, das Schlüssel pro Client ausstellt

Sobald mehr als eine Person oder Anwendung das Modell aufruft, reicht ein gemeinsames Token nicht mehr aus. Sie können nicht feststellen, welcher Client die Last verursacht hat, und keinen einzelnen Client sperren, ohne alle anderen ebenfalls zu sperren. Ein Gateway übernimmt die Position des Proxys, verwendet dieselbe OpenAI-kompatible API, stellt pro Client einen eigenen Schlüssel aus und protokolliert, welche Nutzung auf den jeweiligen Schlüssel entfällt. Ein selbst gehostetes LiteLLM-Gateway ist dafür die übliche Lösung. Zusätzlich zur Zugriffskontrolle bietet es Budgets pro Schlüssel und Anforderungsprotokolle.

Die Regel aus Abwehr 1 bleibt unverändert. Ollama bindet an 127.0.0.1, nur das Gateway kommuniziert mit Ollama, und nur das Gateway stellt einen öffentlich erreichbaren Listener bereit. Ein Gateway auf einem System, auf dem Port 11434 weiterhin weltweit offen ist, ist wirkungslos, weil Clients es einfach umgehen können.

Die Firewall-Falle: Ein veröffentlichter Container-Port umgeht UFW

Deshalb gibt es erreichbare Instanzen auf Servern, deren Betreiber eine Firewall korrekt konfiguriert haben.

UFW (uncomplicated firewall) schreibt seine Regeln in die INPUT-Chain der Kernel-Tabelle filter. INPUT verarbeitet Pakete, die an den Host selbst adressiert sind. Das -p-Flag von Docker schreibt eine Destination-NAT-Regel (Network Address Translation) in die PREROUTING-Chain der Tabelle nat. Der Kernel wertet diese Regel aus, bevor er entscheidet, wohin das Paket geht. Wenn die Routing-Entscheidung erfolgt, wurde das Ziel bereits in die Adresse des Containers geändert. Das Paket wird daher weitergeleitet, statt lokal zugestellt zu werden, und durchläuft FORWARD statt INPUT. Die INPUT-Regeln von UFW werden nie ausgewertet. Das Paket umgeht die Firewall, statt sie zu durchlaufen.

Deshalb lässt diese Sequenz Port 11434 aus dem Internet erreichbar:

sudo ufw default deny incoming
sudo ufw enable
docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

und sudo ufw status meldet weiterhin, dass die Firewall aktiv ist und standardmäßig alle Verbindungen ablehnt. Beide Anzeigen sind gleichzeitig korrekt. Genau deshalb verlassen sich viele auf die falsche Anzeige. Die dafür verantwortliche Regel sehen Sie mit:

sudo iptables -t nat -L DOCKER -n

Die Lösung besteht aus einer Adresse im Publish-Flag:

docker rm -f ollama
docker run -d -v ollama:/root/.ollama -p 127.0.0.1:11434:11434 --name ollama ollama/ollama

-p 11434:11434 enthält keine Hostadresse. Docker veröffentlicht den Port daher auf jeder Hostadresse, sowohl IPv4 (0.0.0.0) als auch IPv6 ([::]). Mit 127.0.0.1 wird die Hostseite des Mappings an Loopback gebunden. Dadurch erreichen Ihr SSH-Tunnel und Ihr Reverse Proxy den Port weiterhin, das Internet jedoch nicht. Docker-Versionen vor 28.0.0 bilden eine Ausnahme: Rechner im selben Netzwerksegment können Ports erreichen, die an localhost veröffentlicht wurden. Führen Sie daher ein Upgrade durch, bevor Sie sich auf diesen Schutz verlassen. Das Neuerstellen des Containers ist hier sicher, weil die Modelle im benannten ollama-Volume liegen und nicht im Container.

Bestätigen Sie, dass beide Ansichten übereinstimmen:

docker port ollama
sudo ss -tlnp | grep 11434

docker port ollama sollte 11434/tcp -> 127.0.0.1:11434 ausgeben. Wenn 0.0.0.0:11434 oder [::]:11434 ausgegeben wird, ist der Port weiterhin erreichbar. Wenn Sie den Mechanismus einmal verstanden haben, können Sie ihn auf jeden Container anwenden, den Sie veröffentlichen: warum veröffentlichte Docker-Ports UFW umgehen behandelt die DOCKER-USER-Chain und die Regeln, die einen Docker-Neustart überstehen. Wenn Sie die Host-Firewall noch einrichten, behandelt die UFW-Regeln für einen neuen VPS die Grundlage, auf der dies aufbaut. Auf Rocky oder AlmaLinux gibt es keine UFW-Konfiguration. Beginnen Sie stattdessen mit derselben Basisrichtlinie in firewalld.

Unter welchem Benutzerkonto läuft der Prozess?

Das Linux-Installationsskript erstellt ein eigenes Benutzerkonto und führt den Dienst darunter aus:

useradd -r -s /bin/false -U -m -d /usr/share/ollama ollama

Die Unit unter /etc/systemd/system/ollama.service setzt anschließend User=ollama und Group=ollama. Ändern Sie diese Konfiguration nicht. Ein manuell in einem Terminal gestartetes ollama serve läuft unter dem Benutzerkonto, mit dem Sie angemeldet sind. Ist das root, schreibt eine nicht authentifizierte API Dateien als root. Prüfen Sie das Benutzerkonto:

ps -o user= -C ollama

Das Ergebnis sollte ollama sein. Jedes andere Ergebnis bedeutet, dass neben der Unit oder an ihrer Stelle ein manuell gestarteter Prozess läuft. Dasselbe gilt für jeden weiteren Daemon, den Sie später hinzufügen. Dienste mit Benutzerkonten und den geringsten erforderlichen Berechtigungen ausführen setzt dieses Prinzip korrekt um.

So prüfen Sie, ob der Ollama-API-Endpunkt sicher ist

Unabhängig von Ihrer Konfiguration gibt nur ein Test Gewissheit. Er muss von einem anderen Rechner aus ausgeführt werden:

curl -m 5 http://YOUR_SERVER_IP:11434/api/version
curl -m 5 http://YOUR_SERVER_IP:11434/api/tags

Beide Verbindungen sollten in einen Timeout laufen oder abgewiesen werden. Wenn Sie einen Proxy eingerichtet haben, sollten dieselben beiden Pfade über den Proxy-Hostnamen ohne Anmeldedaten 401 zurückgeben und mit Anmeldedaten gültiges JSON liefern.

Lesen Sie anschließend das Access-Log einmal aus. Berücksichtigen Sie dabei die Anfragen, die während des geöffneten Ports eingegangen sind:

journalctl -u ollama --since "-30 days" | grep GIN

Ollama schreibt für jede Anfrage eine Zeile und enthält darin die Client-Adresse:

[GIN] 2026/08/12 - 14:01:10 | 200 | 103.965898ms | 127.0.0.1 | POST "/api/generate"

Diese Adresse stammt aus Gins ClientIP(). Dabei werden auch die Header X-Forwarded-For und X-Real-IP von vertrauenswürdigen Proxys geprüft. Eine Anfrage über einen Reverse Proxy auf dem Loopback-Interface kann daher eine öffentliche Client-Adresse anzeigen, während Ollama korrekt an 127.0.0.1 gebunden ist. Eine öffentliche Adresse in dieser Spalte beweist keinen direkten Zugriff auf Port 11434. Fehlende passende Logzeilen beweisen ebenfalls nicht, dass niemand den Port erreicht hat. Vergleichen Sie die Zeitstempel mit den Proxy-Logs und der Konfiguration. Verwenden Sie den externen Verbindungstest, um die aktuelle Erreichbarkeit zu prüfen. Wenn dieser Teil von Ollama für Sie neu ist, behandelt Ollama auf einem VPS ausführen die Installation, die Dimensionierung der Modelle und die Speichergrenzen, die bestimmen, welche Modelle tatsächlich geladen werden.

FAQ

Hat Ollama einen API-Key oder ein Passwort?

Nein. Der von Ihnen gestartete Server hat keinerlei Authentifizierung, und die offizielle Dokumentation weist darauf hin, dass die lokale API keine Authentifizierung erfordert. Die beiden Dinge, die als „Ollama API key“ bezeichnet werden, dienen jeweils einem anderen Zweck. Das Ed25519-Schlüsselpaar in /usr/share/ollama/.ollama/ weist Ihren Rechner gegenüber ollama.com aus, damit Sie Modelle übertragen und private Modelle abrufen können. OLLAMA_API_KEY ist ein Zugangsdaten-Token, den Ihr Client an die gehostete API unter https://ollama.com/api sendet. Ihre eigene ollama serve verwendet keines von beiden zur Authentifizierung eingehender Clients. Die Zugriffskontrolle muss daher aus dem Netzwerk oder aus einem vorgeschalteten Proxy kommen.

Ist OLLAMA_HOST=0.0.0.0 sicher, wenn ich eine Firewall habe?

Nur wenn die Firewall den Zugriff auf diesen Listener korrekt blockiert. 0.0.0.0 bedeutet, dass der Listener tatsächlich auf der öffentlichen Schnittstelle vorhanden ist und Sie allein darauf vertrauen, dass die Firewall ihn unerreichbar hält. Ein von Docker veröffentlichter Ollama-Port erfordert besondere Beachtung, weil die von Docker zur nat-Tabelle hinzugefügte DNAT-Regel ausgewertet wird, bevor das Paket die INPUT-Chain erreicht, in der UFW arbeitet. Das Paket wird daher weitergeleitet, und die INPUT-Regeln von UFW sehen es nie. Wenn Sie an 127.0.0.1 oder an eine Adresse eines privaten Tunnels binden, wird der Listener von der öffentlichen Schnittstelle entfernt. Ein Fehler in der Firewall kann dann nichts mehr exponieren.

Wie prüfe ich, ob mein Ollama-Port aus dem Internet erreichbar ist?

Führen Sie sudo ss -tlnp | grep 11434 auf dem Server und curl -m 5 http://YOUR_SERVER_IP:11434/api/version von einem anderen Rechner aus. Wenn ss 127.0.0.1:11434 anzeigt und der entfernte curl-Aufruf mit einem Timeout abbricht, sind das die erwarteten Ergebnisse. Wenn ss 0.0.0.0:11434 oder *:11434 anzeigt und der entfernte curl-Aufruf JSON zurückgibt, ist die vollständige API erreichbar. Ein curl-Test direkt auf dem Server zeigt nicht, ob ein anderer Rechner den Dienst erreichen kann.

Kann ich den Port einfach von 11434 auf einen zufälligen Port verschieben?

Nein. Der Grund dafür ist wichtig. Ein anderer Port verlangsamt nur einen Scan dieses einzelnen Ports. Scanner prüfen den gesamten Portbereich, und eine Anfrage an /api/tags identifiziert den Dienst unabhängig davon, an welchem Port sie eingegangen ist. Das Verschieben des Ports macht außerdem alle Client-Standardeinstellungen ungültig und erschwert es später, die eigene Konfiguration nachzuvollziehen. Binden Sie stattdessen an Loopback. Dadurch wird der Listener entfernt, anstatt ihn nur zu verschieben.

Jemand hat meinen offenen Ollama-Dienst erreicht. Was sollte ich prüfen?

Binden Sie ihn zuerst an 127.0.0.1 und starten Sie den Dienst neu, damit die Exponierung beendet ist, bevor Sie mit der Untersuchung beginnen. Führen Sie anschließend journalctl -u ollama --since "-30 days" | grep GIN aus, um Client-Adressen, Endpunkte und Zeitstempel zu prüfen. Gin wertet außerdem weitergeleitete Client-Adress-Header aus. Vergleichen Sie diese Einträge daher mit den Logs Ihres Proxys, bevor Sie eine Adresse als Beleg für direkten Zugriff betrachten. Vergleichen Sie ollama list mit den Modellen, die vorhanden sein sollten. /api/pull ist nicht authentifiziert, und ein Modell, das Sie nicht abgerufen haben, bedeutet sowohl belegten Speicherplatz als auch einen Hinweis auf einen Zugriff. Prüfen Sie den freien Speicherplatz mit df -h. Das standardmäßige Access-Log zeichnet Anfrage-Metadaten auf, nicht den Modellnamen, den Prompt-Text oder die generierte Antwort.

War dieser Artikel hilfreich?