Wie man eine Authentifizierung mit Haystack hinzufügt (Schritt für Schritt)

Die drei wichtigsten Ansätze, die bei Haystack-Implementierungen populär sind:

Persönlich empfehle ich OAuth2 mit JWT-Token für jedes Projekt, das über „nur ich benutze es“ hinausgeht. API-Schlüssel sind zwar einfach, werden jedoch zum Kopfzerbrechen, wenn Sie mehrere Verbraucher haben oder den Zugriff widerrufen müssen. Basic Auth fühlt sich hier an wie das dunkle Zeitalter—da gibt es keinen Grund, das zu leugnen.

Schritt 2: FastAPI mit JWT-Authentifizierung einrichten

Wenn Sie Ihre Haystack-API noch nicht in FastAPI eingebettet haben, ist jetzt ein großartiger Zeitpunkt. Dieses Tutorial geht davon aus, dass Sie Ihre Haystack-Pipeline über FastAPI bereitstellen—Sie können sie mit Uvicorn ausführen. Hier ist die minimale FastAPI-Konfiguration mit JWT-Authentifizierung unter Verwendung von python-jose und passlib zur Passwort-Hashing.

from fastapi import FastAPI, Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
from jose import JWTError, jwt
from passlib.context import CryptContext
from datetime import datetime, timedelta
from typing import Optional

# Geheimschlüssel für JWT-Kodierung/Dekodierung – halten Sie dies sehr geheim in Umgebungsvariablen oder Tresoren
SECRET_KEY = "supersecretkey-please-change"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30

pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

app = FastAPI()

fake_users_db = {
 "johndoe": {
 "username": "johndoe",
 "full_name": "John Doe",
 "email": "[email protected]",
 "hashed_password": pwd_context.hash("secret"),
 "disabled": False,
 }
}

def verify_password(plain_password, hashed_password):
 return pwd_context.verify(plain_password, hashed_password)

def get_user(db, username: str):
 if username in db:
 user_dict = db[username]
 return user_dict

def authenticate_user(db, username: str, password: str):
 user = get_user(db, username)
 if not user:
 return False
 if not verify_password(password, user["hashed_password"]):
 return False
 return user

def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
 to_encode = data.copy()
 expire = datetime.utcnow() + (expires_delta or timedelta(minutes=15))
 to_encode.update({"exp": expire})
 encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
 return encoded_jwt

@app.post("/token")
async def login(form_data: OAuth2PasswordRequestForm = Depends()):
 user = authenticate_user(fake_users_db, form_data.username, form_data.password)
 if not user:
 raise HTTPException(
 status_code=status.HTTP_401_UNAUTHORIZED,
 detail="Falscher Benutzername oder Passwort",
 headers={"WWW-Authenticate": "Bearer"},
 )
 access_token = create_access_token(data={"sub": user["username"]}, expires_delta=timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES))
 return {"access_token": access_token, "token_type": "bearer"}

async def get_current_user(token: str = Depends(oauth2_scheme)):
 credentials_exception = HTTPException(
 status_code=status.HTTP_401_UNAUTHORIZED,
 detail="Konnte die Anmeldeinformationen nicht validieren",
 headers={"WWW-Authenticate": "Bearer"},
 )
 try:
 payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
 username: str = payload.get("sub")
 if username is None:
 raise credentials_exception
 except JWTError:
 raise credentials_exception
 user = get_user(fake_users_db, username)
 if user is None:
 raise credentials_exception
 return user

# Geschützter Routenbeispiel
@app.get("/users/me")
async def read_users_me(current_user: dict = Depends(get_current_user)):
 return current_user

Warum das wichtig ist: Sie können nicht einfach ein Auth-Token hinzufügen und damit den Tag beenden. Dieser FastAPI-Schnipsel ist erprobt und nutzt python-jose und passlib, Bibliotheken, denen Entwickler weitgehend vertrauen. Wir vermeiden auch das Speichern von Klartext-Passwörtern—eine Falle, in die einige Tutorials tappen. Das gehashte Passwort in fake_users_db ist einfach ein Platzhalter, aber harten Sie keine Geheimnisse in Ihren realen Projekten—lesen Sie weiter für ein besseres Geheimnismanagement.

Hinweis zu häufigen Fehlern: Wenn Sie einen 401 Unauthorized bei gültigen Anmeldeinformationen erhalten, überprüfen Sie die Token-URL in Ihrem OAuth2PasswordBearer-Aufruf—sie muss mit dem echten Token-URL-Endpunkt übereinstimmen. Auch der SECRET_KEY muss konsistent bleiben – eine Änderung macht alle vorhandenen Tokens ungültig.

Schritt 3: Integrieren Sie die Authentifizierung in Ihre Haystack-API

Jetzt, wo Sie FastAPI mit JWT richtig eingerichtet haben, lassen Sie uns Ihre Haystack-Routen schützen. Angenommen, Sie haben einen Endpunkt, der Ihre Haystack-Pipeline ausführt, um Suchanfragen oder RAG-Komplettierungen zu bedienen. Wickeln Sie ihn um die get_current_user Abhängigkeit, um die Authentifizierung durchzusetzen.

from haystack.document_stores import FAISSDocumentStore
from haystack.nodes import DensePassageRetriever
from haystack.pipelines import ExtractiveQAPipeline

# Dummy-Initialisierung - ersetzen Sie dies durch Ihren tatsächlichen Dokumentenspeicher und Abrufalgorithmus
document_store = FAISSDocumentStore(faiss_index_factory_str="Flat")
retriever = DensePassageRetriever(document_store=document_store)
pipeline = ExtractiveQAPipeline(reader=None, retriever=retriever)

@app.post("/search")
async def haystack_search(question: str, current_user: dict = Depends(get_current_user)):
 """
 Geschützter Such-API-Endpunkt, der ein gültiges Token erfordert.
 """
 # In einer realen Implementierung würden Sie die Pipeline mit der Abfrage ausführen
 result = pipeline.run(query=question, params={"Retriever": {"top_k": 10}})
 return result

Der Schlüssel hier ist die current_user Abhängigkeit—sie zwingt den Endpunkt, Anfragen ohne ein gültiges Bearer-Token abzulehnen. Kein Herumhantieren mit API-Schlüsseln in Headern; das ist der richtige, standardkonforme Ansatz.

Warum Sie das wollen: Haystack’s offene API ist leistungsstark, aber völlig exponiert, wenn Sie die Authentifizierung ignorieren. Das Problem ist größer als „jemand googelt Ihre Elasticsearch-Abfragen“—es geht darum, den Zugriff auf teure Rechenressourcen zu begrenzen, Benutzerdaten privat zu halten und Prüfspuren zu haben. Dieser Schritt macht Ihren Retriever nicht nur zu einem Spielzeug, sondern zu etwas, das Sie für echte Benutzer einsetzen können.

Achtung vor Stolpersteinen: Ein nerviger Fehler, den ich öfter gesehen habe, als ich zugeben möchte: 422 Unprocessable Entity, wenn Sie vergessen, den Authorization-Header einzufügen. Stellen Sie sicher, dass Ihr Frontend oder Ihre Clients Authorization: Bearer <token> senden, oder Sie bekommen einen stillen Fehler.

Schritt 4: Speichern Sie Geheimnisse sicher – Keine Hardcodierung

Erinnern Sie sich an den dummen SECRET_KEY, den ich Ihnen gezeigt habe? Ja, das können Sie nicht in Ihrem Repo verschicken. Ernsthaft, tun Sie das nicht. Wenn Sie Ihre Geheimnisse einpflegen, verdienen Sie die Datenpannen, die Sie bekommen.

Verwenden Sie Umgebungsvariablen oder besser noch einen Geheimnismanager. Haystack’s Dokumentation erwähnt das Geheimnismanagement, geht aber nur kurz auf die Implementierungsdetails ein. Hier ist die minimale Möglichkeit, es mit Umgebungsvariablen zu tun:

import os

SECRET_KEY = os.getenv("HAYSTACK_SECRET_KEY")
if not SECRET_KEY:
 raise RuntimeError("HAYSTACK_SECRET_KEY Umgebungsvariable nicht gesetzt!")

Sie können dies dann in Ihrer Shell oder CI/CD-Pipeline setzen:

export HAYSTACK_SECRET_KEY="a-very-long-random-secret-key-please-generate-it-safely"
uvicorn my_haystack_api:app --reload

Für ernsthafte Produktionen sollten Sie Tools wie HashiCorp Vault oder AWS Secrets Manager erkunden. Die eigene Dokumentation zur Geheimnisverwaltung von Haystack enthält gute Hinweise, jedoch wenig Beispiele. Meiner Meinung nach ist die ordnungsgemäße Verwaltung von Geheimnissen der Punkt, an dem 90 % der Teams scheitern.

Schritt 5: Testen Sie Ihre Authentifizierungsschicht

Schreiben Sie einige Testskripte. Hier ist ein schnelles Beispiel mit Python-Requests, um sich zu authentifizieren und Ihren gesicherten Endpunkt aufzurufen:

import requests

BASE_URL = "http://127.0.0.1:8000"
USERNAME = "johndoe"
PASSWORD = "secret"

def get_token():
 response = requests.post(f"{BASE_URL}/token", data={"username": USERNAME, "password": PASSWORD})
 response.raise_for_status()
 return response.json().get("access_token")

def search(question, token):
 headers = {"Authorization": f"Bearer {token}"}
 response = requests.post(f"{BASE_URL}/search", params={"question": question}, headers=headers)
 response.raise_for_status()
 return response.json()

def main():
 token = get_token()
 print("Got token", token)
 result = search("Was ist Haystack?", token)
 print("Suchergebnis:", result)

if __name__ == "__main__":
 main()

Dies ist der absolute Minimaltest, den Sie benötigen, um zu bestätigen, dass der gesamte Authentifizierungsflow funktioniert. Fehlt das Zugangstoken oder werden die Header durcheinandergebracht, werden Sie sofort mit 401-Fehlern konfrontiert. Sagen Sie nicht, ich habe Sie nicht gewarnt.

Die Tücken, über die niemand Sie warnt

• Token-Ablauf-Hölle: JWT-Ablaufzeiten sind eine Höflichkeit, keine Garantie. Wenn Ihre Tokens zu kurzlebig sind, werden die Benutzer ständig abgemeldet. Zu lang? Sie riskieren, dass gestohlene Tokens ewig verwendet werden. Finden Sie ein Gleichgewicht basierend auf Ihren Benutzertypen und der Fähigkeit, Tokens zu widerrufen.
• Albträume bei der Geheimnisrotation: Wenn Sie Ihren geheimen Schlüssel ändern, werden alle aktuellen Tokens sofort ungültig. Planen Sie die Geheimrotierung sorgfältig oder bauen Sie einen Fallback-Mechanismus ein. Dies wird in vielen Tutorials übergangen, kann aber in der Produktion schwerwiegende Probleme verursachen.
• Fehlendes HTTPS: JWT oder API-Schlüssel ohne HTTPS zu senden? Das könnte auch gleich bedeuten, Ihre Tokens auf Plakatwänden zu drucken. Testen Sie überhaupt nicht über HTTP, es sei denn, lokal. Es ist schmerzhaft offensichtlich, wird aber in Testumgebungen oft übersehen.
• Keine Ratenbegrenzung: Authentifizierung ohne Ratenbegrenzung ist wie das Abschließen der Haustür, aber das Offenlassen der Fenster. Haystack enthält keine Ratenbegrenzung – Sie müssen Middleware oder API-Gateway-Regeln hinzufügen. Erwarten Sie bruteforce-Angriffe oder Versuche zur Aufzählung von Tokens.
• Ignorieren der Geheimnisspeicherung: Ihre Geheimnisse in Umgebungsvariablen zu speichern, ist das Minimum. Aber das Speichern von geheimen Informationen in Protokollen, Fehlermeldungen oder Code-Repositories bleibt viel zu oft unter dem Radar. Nehmen Sie die Geheimhaltung genauso ernst wie Ihre Modelle.

Voll funktionsfähiges Beispiel: Haystack API mit JWT-Authentifizierung

Hier ist, was Sie erhalten, wenn Sie alles zusammenfügen. Führen Sie dies als main.py aus, setzen Sie Ihre HAYSTACK_SECRET_KEY-Umgebungsvariable und führen Sie uvicorn main:app --reload aus.

import os
from fastapi import FastAPI, Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
from jose import JWTError, jwt
from passlib.context import CryptContext
from datetime import datetime, timedelta
from typing import Optional
from haystack.document_stores import FAISSDocumentStore
from haystack.nodes import DensePassageRetriever
from haystack.pipelines import ExtractiveQAPipeline

SECRET_KEY = os.getenv("HAYSTACK_SECRET_KEY")
if not SECRET_KEY:
 raise RuntimeError("HAYSTACK_SECRET_KEY-Umgebungsvariable nicht gesetzt!")

ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30

pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

app = FastAPI()

fake_users_db = {
 "johndoe": {
 "username": "johndoe",
 "full_name": "John Doe",
 "email": "[email protected]",
 "hashed_password": pwd_context.hash("secret"),
 "disabled": False,
 }
}

def verify_password(plain_password, hashed_password):
 return pwd_context.verify(plain_password, hashed_password)

def get_user(db, username: str):
 if username in db:
 user_dict = db[username]
 return user_dict

def authenticate_user(db, username: str, password: str):
 user = get_user(db, username)
 if not user:
 return False
 if not verify_password(password, user["hashed_password"]):
 return False
 return user

def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
 to_encode = data.copy()
 expire = datetime.utcnow() + (expires_delta or timedelta(minutes=15))
 to_encode.update({"exp": expire})
 encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
 return encoded_jwt

@app.post("/token")
async def login(form_data: OAuth2PasswordRequestForm = Depends()):
 user = authenticate_user(fake_users_db, form_data.username, form_data.password)
 if not user:
 raise HTTPException(
 status_code=status.HTTP_401_UNAUTHORIZED,
 detail="Falscher Benutzername oder Passwort",
 headers={"WWW-Authenticate": "Bearer"},
 )
 access_token = create_access_token(data={"sub": user["username"]}, expires_delta=timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES))
 return {"access_token": access_token, "token_type": "bearer"}

async def get_current_user(token: str = Depends(oauth2_scheme)):
 credentials_exception = HTTPException(
 status_code=status.HTTP_401_UNAUTHORIZED,
 detail="Konnte Anmeldeinformationen nicht validieren",
 headers={"WWW-Authenticate": "Bearer"},
 )
 try:
 payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
 username: str = payload.get("sub")
 if username is None:
 raise credentials_exception
 except JWTError:
 raise credentials_exception
 user = get_user(fake_users_db, username)
 if user is None:
 raise credentials_exception
 return user

# Haystack-Komponenten initialisieren
document_store = FAISSDocumentStore(faiss_index_factory_str="Flat")
retriever = DensePassageRetriever(document_store=document_store)
pipeline = ExtractiveQAPipeline(reader=None, retriever=retriever)

@app.post("/search")
async def haystack_search(question: str, current_user: dict = Depends(get_current_user)):
 result = pipeline.run(query=question, params={"Retriever": {"top_k": 10}})
 return result

Dieses Beispiel ist nicht zum Kopieren und Einfügen für die Produktion geeignet, zeigt aber jedes kritische Stück in einer einzigen Datei.

Was kommt als Nächstes: Fügen Sie rollenbasierte Zugriffskontrollen (RBAC) hinzu

Die Authentifizierung per Benutzername/Passwort und Bearer-Token ist gut, aber wenn Ihre App wächst, benötigen Sie Benutzerrollen und Berechtigungen – Administrator, Benutzer, Gast, nur-Lesen, Schreiben usw. Integrieren Sie RBAC, damit Sie einschränken können, wer kostspielige Abfragen durchführen oder Ihr zugrunde liegendes Wissensspeicher aktualisieren kann. Haystack hat kein eingebautes RBAC, aber die Kombination von FastAPIs Abhängigkeitsinjektion mit einer Benutzer-/Rollendatenbank ist unkompliziert. Sobald dies erledigt ist, wird Ihre App nicht nur sicher, sondern auch logisch sein.

FAQ

Q: Kann ich API-Schlüssel anstelle von JWT-Token mit Haystack verwenden?

A: Ja, aber ich empfehle es nicht für die Produktion. API-Schlüssel sind einfacher, haben jedoch keine Ablaufzeiten, Widerrufsmöglichkeiten und feingranulare Zugriffskontrolle. Sie können die API-Schlüssel-Authentifizierung über FastAPI-Header-Überprüfungen implementieren, aber für jeden Multi-User- oder sensiblen Anwendungsfall ist JWT mit OAuth2 die bessere, zukunftssichere Wahl.

Q: Wie schütze ich die Haystack UI (wenn verwendet)?

A: Haystack’s UI-Komponenten sind nur React-Apps oder Dashboards – Sie sollten sicherstellen, dass Ihr Webserver oder Reverse Proxy die Authentifizierung durchsetzt (z. B. nginx mit auth_basic, OAuth-Proxy) oder Ihre Backend-Authentifizierungstoken sicher im Frontend einbetten. Die Authentifizierung im Backend von FastAPI schützt nicht von sich aus die statischen UI-Ressourcen.

Q: Gibt es in Haystack eine eingebaute Unterstützung für die Authentifizierung?

A: Nein. Haystack konzentriert sich rein auf NLP-Aufgaben. Es wird davon ausgegangen, dass Sie es in Ihre App oder Ihr API-Framework integrieren, das Authentifizierung, Geheimnisse und Benutzermanagement behandelt. Diese Trennung ist schmerzhaft, sorgt jedoch dafür, dass Haystack sich darauf konzentriert, in dem, was es tut, großartig zu sein.

Für verschiedene Entwicklerpersönlichkeiten

Der Solo-Hacker: Halten Sie sich an die API-Schlüssel-Authentifizierung, um schnell funktional zu werden, aber bewahren Sie die Schlüssel außerhalb des Codes. Verwenden Sie FastAPI-Middleware oder Umgebungsvariablen und codieren Sie nichts fest. Ihr Hauptrisiko ist, die Schlüssel versehentlich offenzulegen – tun Sie es nicht.

Der Unternehmensentwickler: Wählen Sie OAuth2 mit JWT-Token, integrieren Sie geheime Tresore (HashiCorp, AWS), aktivieren Sie RBAC und fügen Sie eine Ratenbegrenzung hinzu. Ihr Ziel ist eine verwaltbare, prüfbare Sicherheit um kostspielige Rechenoperationen.

Der Data Scientist/ML Engineer: Arbeiten Sie mit Ihrem Backend-Team zusammen, um die Authentifizierung hinzuzufügen. Sie möchten eine saubere Schnittstelle zu Ihren Haystack-Pipelines, sollten sich jedoch nicht selbst um die Low-Level-Auth-Details kümmern müssen. Verstehen Sie die Grundlagen, um Probleme zu debuggen, aber konzentrieren Sie sich darauf, Modelle zu verbessern.

Daten vom 22. März 2026. Quellen: deepset-ai/haystack GitHub, Haystack-Dokumentation zur Geheimnisverwaltung, Project Haystack-Authentifizierung

Verwandte Artikel

• Fallstudien zur Automatisierung von AI-Agenten-Workflows
• Qdrant im Jahr 2026: 5 Dinge nach 3 Monaten Nutzung
• AI Lebenslauf-Builder: Erstellen Sie Ihren perfekten Lebenslauf schnell!

🕒 Published: March 27, 2026