Zum Hauptinhalt springen

Docker, Deployment

Sie können die Dockerfile zum Erstellen des Litellm-Proxys hier finden.

Schnellstart​

Um Litellm zu verwenden, führen Sie die folgenden Befehle in einer Shell aus.

# Get the code
git clone https://github.com/BerriAI/litellm

# Go to folder
cd litellm

# Add the master key - you can change this after setup
echo 'LITELLM_MASTER_KEY="sk-1234"' > .env

# Add the litellm salt key - you cannot change this after adding a model
# It is used to encrypt / decrypt your LLM API Key credentials
# We recommend - https://1password.com/password-generator/ 
# password generator to get a random hash for litellm salt key
echo 'LITELLM_SALT_KEY="sk-1234"' >> .env

source .env

# Start
docker-compose up

Docker Run​

Schritt 1. CREATE config.yaml​

Beispiel litellm_config.yaml

model_list:
  - model_name: azure-gpt-3.5
    litellm_params:
      model: azure/<your-azure-model-deployment>
      api_base: os.environ/AZURE_API_BASE # runs os.getenv("AZURE_API_BASE")
      api_key: os.environ/AZURE_API_KEY # runs os.getenv("AZURE_API_KEY")
      api_version: "2023-07-01-preview"

Schritt 2. RUN Docker Image​

docker run \
    -v $(pwd)/litellm_config.yaml:/app/config.yaml \
    -e AZURE_API_KEY=d6*********** \
    -e AZURE_API_BASE=https://openai-***********/ \
    -p 4000:4000 \
    ghcr.io/berriai/litellm:main-latest \
    --config /app/config.yaml --detailed_debug

Neuestes Image erhalten 👉 hier

Schritt 3. TEST Request​

Geben Sie model=azure-gpt-3.5 an, dies wurde in Schritt 1 festgelegt.

curl --location 'http://0.0.0.0:4000/chat/completions' \
    --header 'Content-Type: application/json' \
    --data '{
    "model": "azure-gpt-3.5",
    "messages": [
        {
        "role": "user",
        "content": "what llm are you"
        }
    ]
}'

Docker Run - CLI Args​

Alle unterstützten CLI-Argumente finden Sie hier.

Hier erfahren Sie, wie Sie das Docker-Image ausführen und Ihre Konfiguration an litellm übergeben.

docker run ghcr.io/berriai/litellm:main-latest --config your_config.yaml

Hier erfahren Sie, wie Sie das Docker-Image ausführen und litellm auf Port 8002 mit num_workers=8 starten.

docker run ghcr.io/berriai/litellm:main-latest --port 8002 --num_workers 8

Litellm als Basisimage verwenden​

# Use the provided base image
FROM ghcr.io/berriai/litellm:main-latest

# Set the working directory to /app
WORKDIR /app

# Copy the configuration file into the container at /app
COPY config.yaml .

# Make sure your docker/entrypoint.sh is executable
RUN chmod +x ./docker/entrypoint.sh

# Expose the necessary port
EXPOSE 4000/tcp

# Override the CMD instruction with your desired command and arguments
# WARNING: FOR PROD DO NOT USE `--detailed_debug` it slows down response times, instead use the following CMD
# CMD ["--port", "4000", "--config", "config.yaml"]

CMD ["--port", "4000", "--config", "config.yaml", "--detailed_debug"]

Aus dem Litellm pip-Paket erstellen​

Befolgen Sie diese Anweisungen, um einen Docker-Container aus dem Litellm pip-Paket zu erstellen. Wenn Ihr Unternehmen strenge Anforderungen an Sicherheit und das Erstellen von Images hat, können Sie diese Schritte befolgen.

Dockerfile

FROM cgr.dev/chainguard/python:latest-dev

USER root
WORKDIR /app

ENV HOME=/home/litellm
ENV PATH="${HOME}/venv/bin:$PATH"

# Install runtime dependencies
RUN apk update && \
    apk add --no-cache gcc python3-dev openssl openssl-dev

RUN python -m venv ${HOME}/venv
RUN ${HOME}/venv/bin/pip install --no-cache-dir --upgrade pip

COPY requirements.txt .
RUN --mount=type=cache,target=${HOME}/.cache/pip \
    ${HOME}/venv/bin/pip install -r requirements.txt

EXPOSE 4000/tcp

ENTRYPOINT ["litellm"]
CMD ["--port", "4000"]

Beispiel requirements.txt

litellm[proxy]==1.57.3 # Specify the litellm version you want to use
prometheus_client
langfuse
prisma

Das Docker-Image erstellen

docker build \
  -f Dockerfile.build_from_pip \
  -t litellm-proxy-with-pip-5 .

Das Docker-Image ausführen

docker run \
    -v $(pwd)/litellm_config.yaml:/app/config.yaml \
    -e OPENAI_API_KEY="sk-1222" \
    -e DATABASE_URL="postgresql://xxxxxxxxx \
    -p 4000:4000 \
    litellm-proxy-with-pip-5 \
    --config /app/config.yaml --detailed_debug

Terraform​

Vielen Dank an Nicholas Cecere für sein LiteLLM User Management Terraform.

👉 Terraform finden Sie hier.

Kubernetes​

Für die Bereitstellung einer LiteLLM-Instanz basierend auf einer Konfigurationsdatei ist lediglich eine einfache Bereitstellung erforderlich, die die config.yaml-Datei über eine ConfigMap lädt. Außerdem ist es ratsam, Umgebungsvariablen für API-Schlüssel zu verwenden und diese mit den API-Schlüsselwerten als undurchsichtigen Geheimnis anzuhängen.

apiVersion: v1
kind: ConfigMap
metadata:
  name: litellm-config-file
data:
  config.yaml: |
      model_list: 
        - model_name: gpt-3.5-turbo
          litellm_params:
            model: azure/gpt-turbo-small-ca
            api_base: https://my-endpoint-canada-berri992.openai.azure.com/
            api_key: os.environ/CA_AZURE_OPENAI_API_KEY
---
apiVersion: v1
kind: Secret
type: Opaque
metadata:
  name: litellm-secrets
data:
  CA_AZURE_OPENAI_API_KEY: bWVvd19pbV9hX2NhdA== # your api key in base64
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: litellm-deployment
  labels:
    app: litellm
spec:
  selector:
    matchLabels:
      app: litellm
  template:
    metadata:
      labels:
        app: litellm
    spec:
      containers:
      - name: litellm
        image: ghcr.io/berriai/litellm:main-latest # it is recommended to fix a version generally
        ports:
        - containerPort: 4000
        volumeMounts:
        - name: config-volume
          mountPath: /app/proxy_server_config.yaml
          subPath: config.yaml
        envFrom:
        - secretRef:
            name: litellm-secrets
      volumes:
        - name: config-volume
          configMap:
            name: litellm-config-file
Info

Um Probleme mit Vorhersehbarkeit, Schwierigkeiten bei der Rückgängigmachung und inkonsistenten Umgebungen zu vermeiden, verwenden Sie Versionen oder SHA-Digests (z. B. litellm:main-v1.30.3 oder litellm@sha256:12345abcdef...) anstelle von litellm:main-latest.

Helm Chart​

Info

[BETA]Das Helm Chart ist BETA. Wenn Sie auf Probleme stoßen / Feedback haben, lassen Sie es uns bitte wissen https://github.com/BerriAI/litellm/issues.

Verwenden Sie dies, wenn Sie das LiteLLM-Helm-Chart als Abhängigkeit für andere Charts verwenden möchten. Das OCI litellm-helm wird hier gehostet: https://github.com/BerriAI/litellm/pkgs/container/litellm-helm.

Schritt 1. Ziehen Sie das LiteLLM-Helm-Chart​

helm pull oci://ghcr.io/berriai/litellm-helm

# Pulled: ghcr.io/berriai/litellm-helm:0.1.2
# Digest: sha256:7d3ded1c99c1597f9ad4dc49d84327cf1db6e0faa0eeea0c614be5526ae94e2a

Schritt 2. Entpacken Sie das LiteLLM-Helm​

Entpacken Sie die in Schritt 1 abgerufene spezielle Version.

tar -zxvf litellm-helm-0.1.2.tgz

Schritt 3. Installieren Sie das LiteLLM-Helm​

helm install lite-helm ./litellm-helm

Schritt 4. Machen Sie den Dienst für localhost verfügbar​

kubectl --namespace default port-forward $POD_NAME 8080:$CONTAINER_PORT

Ihr LiteLLM Proxy Server läuft jetzt unter http://127.0.0.1:4000.

Das ist alles! Das ist die Schnellanleitung zur Bereitstellung von LiteLLM.

LLM-API-Anfragen stellen​

Info

💡 Gehen Sie hierhin 👉 um Ihre erste LLM-API-Anfrage zu stellen.

LiteLLM ist kompatibel mit mehreren SDKs – einschließlich OpenAI SDK, Anthropic SDK, Mistral SDK, LLamaIndex, Langchain (Js, Python).

Bereitstellungsoptionen​

DokumentationWann man es benutzt
Schnellstart100+ LLMs aufrufen + Load Balancing
Mit Datenbank bereitstellen+ Virtuelle Schlüssel verwenden + Ausgaben verfolgen (Hinweis: Bei der Bereitstellung mit einer Datenbank sind DATABASE_URL und LITELLM_MASTER_KEY in Ihrer Umgebung erforderlich)
LiteLLM-Container + Redis+ Lastenausgleich über mehrere LiteLLM-Container
LiteLLM-Datenbank-Container + PostgresDB + Redis+ Virtuelle Schlüssel verwenden + Ausgaben verfolgen + Lastenausgleich über mehrere LiteLLM-Container

Mit Datenbank bereitstellen​

Docker, Kubernetes, Helm Chart​

Anforderungen

  • Benötigt eine Postgres-Datenbank (z. B. Supabase, Neon usw.). Setzen Sie DATABASE_URL=postgresql://<user>:<password>@<host>:<port>/<dbname> in Ihrer Umgebung.
  • Setzen Sie einen LITELLM_MASTER_KEY. Dies ist Ihr Proxy-Admin-Schlüssel. Sie können ihn verwenden, um andere Schlüssel zu erstellen (🚨 muss mit sk- beginnen).

Wir pflegen eine separate Dockerfile, um die Build-Zeit bei der Ausführung des LiteLLM-Proxys mit einer verbundenen Postgres-Datenbank zu reduzieren.

docker pull ghcr.io/berriai/litellm-database:main-latest
docker run \
    -v $(pwd)/litellm_config.yaml:/app/config.yaml \
    -e LITELLM_MASTER_KEY=sk-1234 \
    -e DATABASE_URL=postgresql://<user>:<password>@<host>:<port>/<dbname> \
    -e AZURE_API_KEY=d6*********** \
    -e AZURE_API_BASE=https://openai-***********/ \
    -p 4000:4000 \
    ghcr.io/berriai/litellm-database:main-latest \
    --config /app/config.yaml --detailed_debug

Ihr LiteLLM Proxy Server läuft jetzt unter http://0.0.0.0:4000.

Mit Redis bereitstellen​

Verwenden Sie Redis, wenn LiteLLM den Lastenausgleich über mehrere LiteLLM-Container durchführen soll.

Die einzige erforderliche Änderung ist die Einrichtung von Redis in Ihrer config.yaml. LiteLLM Proxy unterstützt die gemeinsame Nutzung von RPM/TPM über mehrere LiteLLM-Instanzen hinweg. Übergeben Sie redis_host, redis_password und redis_port, um dies zu aktivieren. (LiteLLM verwendet Redis, um RPM/TPM-Nutzung zu verfolgen).

model_list:
  - model_name: gpt-3.5-turbo
    litellm_params:
      model: azure/<your-deployment-name>
      api_base: <your-azure-endpoint>
      api_key: <your-azure-api-key>
      rpm: 6      # Rate limit for this deployment: in requests per minute (rpm)
  - model_name: gpt-3.5-turbo
    litellm_params:
      model: azure/gpt-turbo-small-ca
      api_base: https://my-endpoint-canada-berri992.openai.azure.com/
      api_key: <your-azure-api-key>
      rpm: 6
router_settings:
  redis_host: <your redis host>
  redis_password: <your redis password>
  redis_port: 1992

Starten Sie den Docker-Container mit Konfiguration.

docker run ghcr.io/berriai/litellm:main-latest --config your_config.yaml

Mit Datenbank + Redis bereitstellen​

Die einzige erforderliche Änderung ist die Einrichtung von Redis in Ihrer config.yaml. LiteLLM Proxy unterstützt die gemeinsame Nutzung von RPM/TPM über mehrere LiteLLM-Instanzen hinweg. Übergeben Sie redis_host, redis_password und redis_port, um dies zu aktivieren. (LiteLLM verwendet Redis, um RPM/TPM-Nutzung zu verfolgen).

model_list:
  - model_name: gpt-3.5-turbo
    litellm_params:
      model: azure/<your-deployment-name>
      api_base: <your-azure-endpoint>
      api_key: <your-azure-api-key>
      rpm: 6      # Rate limit for this deployment: in requests per minute (rpm)
  - model_name: gpt-3.5-turbo
    litellm_params:
      model: azure/gpt-turbo-small-ca
      api_base: https://my-endpoint-canada-berri992.openai.azure.com/
      api_key: <your-azure-api-key>
      rpm: 6
router_settings:
  redis_host: <your redis host>
  redis_password: <your redis password>
  redis_port: 1992

Starten Sie den litellm-database-Docker-Container mit Konfiguration.

docker run --name litellm-proxy \
-e DATABASE_URL=postgresql://<user>:<password>@<host>:<port>/<dbname> \
-p 4000:4000 \
ghcr.io/berriai/litellm-database:main-latest --config your_config.yaml

(Nicht-Root) - ohne Internetverbindung​

Standardmäßig lädt prisma generate die Engine-Binärdateien von Prisma herunter. Dies kann zu Fehlern führen, wenn es ohne Internetverbindung ausgeführt wird.

Verwenden Sie dieses Docker-Image, um LiteLLM mit vorab generierten Prisma-Binärdateien bereitzustellen.

docker pull ghcr.io/berriai/litellm-non_root:main-stable

Link zum veröffentlichten Docker-Image

Erweiterte Bereitstellungseinstellungen​

1. Benutzerdefinierter Server-Root-Pfad (Proxy-Basis-URL)​

💥 Verwenden Sie dies, wenn Sie LiteLLM unter einem benutzerdefinierten Basis-URL-Pfad wie https://:4000/api/v1 bereitstellen möchten.

Info

In einer Kubernetes-Bereitstellung ist es möglich, ein gemeinsames DNS zum Hosten mehrerer Anwendungen zu verwenden, indem der virtuelle Dienst geändert wird.

Passen Sie den Root-Pfad an, um die Notwendigkeit der Verwendung mehrerer DNS-Konfigurationen während der Bereitstellung zu eliminieren.

Schritt 1. 👉 Setzen Sie SERVER_ROOT_PATH in Ihrer .env, und dieser wird als Ihr Server-Root-Pfad festgelegt.

export SERVER_ROOT_PATH="/api/v1"

Schritt 2 (Wenn Sie möchten, dass die Proxy-Admin-UI mit Ihrem Root-Pfad funktioniert, müssen Sie diese Dockerfile verwenden)

  • Verwenden Sie die folgende Dockerfile (sie verwendet LiteLLM als Basisimage).
  • 👉 Setzen Sie UI_BASE_PATH=$SERVER_ROOT_PATH/ui in der Dockerfile, z. B. UI_BASE_PATH=/api/v1/ui.

Dockerfile

# Use the provided base image
FROM ghcr.io/berriai/litellm:main-latest

# Set the working directory to /app
WORKDIR /app

# Install Node.js and npm (adjust version as needed)
RUN apt-get update && apt-get install -y nodejs npm

# Copy the UI source into the container
COPY ./ui/litellm-dashboard /app/ui/litellm-dashboard

# Set an environment variable for UI_BASE_PATH
# This can be overridden at build time
# set UI_BASE_PATH to "<your server root path>/ui"
# 👇👇 Enter your UI_BASE_PATH here
ENV UI_BASE_PATH="/api/v1/ui" 

# Build the UI with the specified UI_BASE_PATH
WORKDIR /app/ui/litellm-dashboard
RUN npm install
RUN UI_BASE_PATH=$UI_BASE_PATH npm run build

# Create the destination directory
RUN mkdir -p /app/litellm/proxy/_experimental/out

# Move the built files to the appropriate location
# Assuming the build output is in ./out directory
RUN rm -rf /app/litellm/proxy/_experimental/out/* && \
    mv ./out/* /app/litellm/proxy/_experimental/out/

# Switch back to the main app directory
WORKDIR /app

# Make sure your entrypoint.sh is executable
RUN chmod +x ./docker/entrypoint.sh

# Expose the necessary port
EXPOSE 4000/tcp

# Override the CMD instruction with your desired command and arguments
# only use --detailed_debug for debugging
CMD ["--port", "4000", "--config", "config.yaml"]

Schritt 3 Erstellen Sie diese Dockerfile.

docker build -f Dockerfile -t litellm-prod-build . --progress=plain

Schritt 4. Proxy mit gesetztem SERVER_ROOT_PATH in Ihrer Umgebung ausführen.

docker run \
    -v $(pwd)/proxy_config.yaml:/app/config.yaml \
    -p 4000:4000 \
    -e LITELLM_LOG="DEBUG"\
    -e SERVER_ROOT_PATH="/api/v1"\
    -e DATABASE_URL=postgresql://<user>:<password>@<host>:<port>/<dbname> \
    -e LITELLM_MASTER_KEY="sk-1234"\
    litellm-prod-build \
    --config /app/config.yaml

Nachdem Sie den Proxy ausgeführt haben, können Sie ihn unter http://0.0.0.0:4000/api/v1/ aufrufen (da wir SERVER_ROOT_PATH="/api/v1" gesetzt haben).

Schritt 5. Verifizieren, dass er auf dem richtigen Pfad läuft.

Das ist alles, was Sie benötigen, um den Proxy auf einem benutzerdefinierten Root-Pfad auszuführen.

2. SSL-Zertifizierung​

Verwenden Sie dies, wenn Sie SSL-Zertifikate für Ihren lokalen LiteLLM-Proxy einrichten müssen.

Übergeben Sie ssl_keyfile_path (Pfad zur SSL-Schlüsseldatei) und ssl_certfile_path (Pfad zur SSL-Zertifikatsdatei), wenn Sie den LiteLLM-Proxy starten.

docker run ghcr.io/berriai/litellm:main-latest \
    --ssl_keyfile_path ssl_test/keyfile.key \
    --ssl_certfile_path ssl_test/certfile.crt

Stellen Sie ein SSL-Zertifikat beim Starten des LiteLLM-Proxy-Servers bereit.

3. Http/2 mit Hypercorn​

Verwenden Sie dies, wenn Sie den Proxy mit Hypercorn ausführen möchten, um HTTP/2 zu unterstützen.

Schritt 1. Erstellen Sie Ihr benutzerdefiniertes Docker-Image mit Hypercorn.

# Use the provided base image
FROM ghcr.io/berriai/litellm:main-latest

# Set the working directory to /app
WORKDIR /app

# Copy the configuration file into the container at /app
COPY config.yaml .

# Make sure your docker/entrypoint.sh is executable
RUN chmod +x ./docker/entrypoint.sh

# Expose the necessary port
EXPOSE 4000/tcp

# 👉 Key Change: Install hypercorn
RUN pip install hypercorn

# Override the CMD instruction with your desired command and arguments
# WARNING: FOR PROD DO NOT USE `--detailed_debug` it slows down response times, instead use the following CMD
# CMD ["--port", "4000", "--config", "config.yaml"]

CMD ["--port", "4000", "--config", "config.yaml", "--detailed_debug"]

Schritt 2. Ãœbergeben Sie das Flag --run_hypercorn, wenn Sie den Proxy starten.

docker run \
    -v $(pwd)/proxy_config.yaml:/app/config.yaml \
    -p 4000:4000 \
    -e LITELLM_LOG="DEBUG"\
    -e SERVER_ROOT_PATH="/api/v1"\
    -e DATABASE_URL=postgresql://<user>:<password>@<host>:<port>/<dbname> \
    -e LITELLM_MASTER_KEY="sk-1234"\
    your_custom_docker_image \
    --config /app/config.yaml
    --run_hypercorn

4. config.yaml-Datei auf S3, GCS Bucket-Objekt/URL​

Verwenden Sie dies, wenn Sie keine Konfigurationsdatei auf Ihrem Bereitstellungsdienst montieren können (Beispiel: AWS Fargate, Railway usw.).

LiteLLM Proxy liest Ihre config.yaml aus einem S3-Bucket oder GCS-Bucket.

Setzen Sie die folgenden .env-Variablen.

LITELLM_CONFIG_BUCKET_TYPE = "gcs"                              # set this to "gcs"         
LITELLM_CONFIG_BUCKET_NAME = "litellm-proxy"                    # your bucket name on GCS
LITELLM_CONFIG_BUCKET_OBJECT_KEY = "proxy_config.yaml"         # object key on GCS

Starten Sie den LiteLLM-Proxy mit diesen Umgebungsvariablen – LiteLLM liest Ihre Konfiguration von GCS.

docker run --name litellm-proxy \
   -e DATABASE_URL=<database_url> \
   -e LITELLM_CONFIG_BUCKET_NAME=<bucket_name> \
   -e LITELLM_CONFIG_BUCKET_OBJECT_KEY="<object_key>> \
   -e LITELLM_CONFIG_BUCKET_TYPE="gcs" \
   -p 4000:4000 \
   ghcr.io/berriai/litellm-database:main-latest --detailed_debug

Plattformspezifischer Leitfaden​

Kubernetes (AWS EKS)​

Schritt 1. Erstellen Sie einen EKS-Cluster mit der folgenden Spezifikation.

eksctl create cluster --name=litellm-cluster --region=us-west-2 --node-type=t2.small

Schritt 2. Montieren Sie die LiteLLM-Proxy-Konfiguration im Kub-Cluster.

Dies montiert Ihre lokale Datei namens proxy_config.yaml im Kubernetes-Cluster.

kubectl create configmap litellm-config --from-file=proxy_config.yaml

Schritt 3. Wenden Sie kub.yaml und service.yaml an. Klonen Sie die folgenden kub.yaml- und service.yaml-Dateien und wenden Sie sie lokal an.

Wenden Sie kub.yaml an.

kubectl apply -f kub.yaml

Wenden Sie service.yaml an – dies erstellt einen AWS-Load-Balancer, um den Proxy verfügbar zu machen.

kubectl apply -f service.yaml

# service/litellm-service created

Schritt 4. Proxy-Basis-URL abrufen.

kubectl get services

# litellm-service   LoadBalancer   10.100.6.31   a472dc7c273fd47fd******.us-west-2.elb.amazonaws.com   4000:30374/TCP   63m

Proxy-Basis-URL = a472dc7c273fd47fd******.us-west-2.elb.amazonaws.com:4000.

Das ist alles, jetzt können Sie mit dem LiteLLM-Proxy beginnen.

Extras​

Docker Compose​

Schritt 1

Hier ist eine Beispiel-docker-compose.yml-Datei.

version: "3.9"
services:
  litellm:
    build:
      context: .
      args:
        target: runtime
    image: ghcr.io/berriai/litellm:main-latest
    ports:
      - "4000:4000" # Map the container port to the host, change the host port if necessary
    volumes:
      - ./litellm-config.yaml:/app/config.yaml # Mount the local configuration file
    # You can change the port or number of workers as per your requirements or pass any new supported CLI argument. Make sure the port passed here matches with the container port defined above in `ports` value
    command: [ "--config", "/app/config.yaml", "--port", "4000", "--num_workers", "8" ]

# ...rest of your docker-compose config if any

Schritt 2

Erstellen Sie eine Datei litellm-config.yaml mit Ihrer LiteLLM-Konfiguration relativ zu Ihrer docker-compose.yml-Datei.

Überprüfen Sie die Konfigurationsdokumentation hier.

Schritt 3

Führen Sie den Befehl docker-compose up oder docker compose up aus, je nach Ihrer Docker-Installation.

Verwenden Sie das Flag -d, um den Container im Detached-Modus (im Hintergrund) auszuführen, z. B. docker compose up -d.

Ihr LiteLLM-Container sollte jetzt unter dem definierten Port, z. B. 4000, laufen.

IAM-basierte Authentifizierung für RDS DB​

  1. Setzen Sie AWS-Umgebungsvariablen.
export AWS_WEB_IDENTITY_TOKEN='/path/to/token'
export AWS_ROLE_NAME='arn:aws:iam::123456789012:role/MyRole'
export AWS_SESSION_NAME='MySession'

Alle Authentifizierungsoptionen anzeigen.

  1. RDS-Anmeldeinformationen zur Umgebung hinzufügen.
export DATABASE_USER="db-user"
export DATABASE_PORT="5432"
export DATABASE_HOST="database-1-instance-1.cs1ksmwz2xt3.us-west-2.rds.amazonaws.com"
export DATABASE_NAME="database-1-instance-1"
export DATABASE_SCHEMA="schema-name" # skip to use the default "public" schema
  1. Proxy mit IAM+RDS ausführen.
litellm --config /path/to/config.yaml --iam_token_db_auth

✨ Web-Crawler blockieren​

Hinweis: Dies ist eine Funktion, die nur in der Enterprise-Version verfügbar ist.

Um Web-Crawler vom Indexieren der Proxy-Server-Endpunkte abzuhalten, setzen Sie die Einstellung block_robots in Ihrer Datei litellm_config.yaml auf true.

litellm_config.yaml
general_settings:
  block_robots: true

Wie es funktioniert​

Wenn dies aktiviert ist, gibt der Endpunkt /robots.txt einen 200-Statuscode mit folgendem Inhalt zurück:

robots.txt
User-agent: *
Disallow: /