Blog · Deploy-Anleitungen

So deployst du eine Streamlit-App 2026: ein Befehl, HTTPS und ein Dockerfile, das bleibt

Vom Pethost-Team · 25. Oktober 2026 · 11 Min. Lesezeit

Du hast eine Streamlit-App, die auf deinem Laptop mit streamlit run läuft, und willst sie unter einer Adresse mit HTTPS online haben, für Leute, die kein Python haben. Bei Pethost ist das ein Befehl, pethost deploy, ausgeführt im Ordner mit der requirements.txt. Er schreibt das Dockerfile, baut die App auf deiner Pethost-Maschine und gibt ihre Adresse aus. Die App aus den ersten Seiten der Streamlit-Doku war in 52 s online, eine spätere Änderung an ihrem Code in 3 s.

Was du brauchst, um eine Streamlit-App 2026 zu deployen

Drei Dinge: die App, den Befehl pethost und ein Pethost-Konto.

Die App ist hier die, mit der dich die Doku von Streamlit anfangen lässt. Ihre Installationsanleitung legt im Ordner des Projekts eine virtuelle Umgebung an und installiert Streamlit hinein:

$ cd my-app
$ python -m venv .venv
$ source .venv/bin/activate
$ pip install streamlit

Dann die streamlit_app.py, mit dem Slider aus der ersten Lektion von Streamlit:

import streamlit as st

st.title("My app")

x = st.slider("x")  # 👈 this is a widget
st.write(x, "squared is", x * x)

Und die requirements.txt, die Liste dessen, was die App installiert, mit einer Zeile: streamlit.

Der Befehl ist ein Programm, installiert mit einer Zeile. Jeder seiner Befehle steht in der Referenz der CLI.

curl -fsSL https://pethost.dev/install.sh | sh      # macOS, Linux
irm https://pethost.dev/install.ps1 | iex           # Windows, in PowerShell

Das Konto braucht einen Tarif. Bist du nicht angemeldet, öffnet pethost deploy deinen Browser und meldet dich an. Hast du noch keinen Tarif, zeigt er dir, wo du einen wählst, und wartet.

Die Streamlit-App mit einem Befehl deployen

Geh in den Ordner mit der requirements.txt und führ pethost deploy aus. Das ist der ganze Bildschirm:

$ pethost deploy
Name it [my-app]:                it will live at https://my-app.sam.pethost.app
✓ Packed 2 files, 131 B   (left out .venv)
✓ Uploaded straight to your machine
✗ /compose.yaml: the project directory has no compose.yaml at its root: add one
✓ Streamlit app detected, wrote Dockerfile and .dockerignore.
✓ Packed 4 files, 601 B   (left out .venv)
✓ Uploaded straight to your machine
✓ Built and started in 52 s
  · wrote compose.yaml for the Dockerfile: the service app, reading .env, port 8501
✓ app listens on 8501 → https://my-app.sam.pethost.app
  It answers 200.

https://my-app.sam.pethost.app

Wrote .pethost (commit it). Next:   pethost logs -f   ·   pethost open

1. Er fragt eine Sache Den Namen des Projekts, das erste Wort seiner Adresse. Enter übernimmt den Namen des Ordners.
2. Er lässt die virtuelle Umgebung weg .venv enthielt 450 MB Pakete, die die Maschine selbst installiert.
3. Die Maschine findet nichts zum Ausführen Die Zeile mit dem Kreuz: Der Ordner hat noch kein Dockerfile und keine Compose-Datei.
4. pethost schreibt das Dockerfile Die requirements.txt nennt streamlit, also schreibt er das für Streamlit und lädt den Ordner noch einmal hoch.
5. Die Maschine baut und startet die App Sie sieht, dass die App auf 8501 lauscht, leitet die HTTPS-Adresse dorthin, und pethost gibt die Antwort aus: 200.

Die Datei .pethost sagt, welches Projekt dieser Ordner ist. Committe sie mit dem Dockerfile, und der nächste Deploy fragt nichts.

Die App öffnen: Widgets und der WebSocket

Eine Streamlit-Seite erreicht die App über einen WebSocket, /_stcore/stream: Jedes Widget, das du bewegst, geht darüber, und das Skript läuft auf dem Server noch einmal. Schlägt das fehl, zeigt die Seite für immer ihr Lade-Skelett; die Knowledge Base von Streamlit macht CORS dafür verantwortlich oder einen Proxy, der die Header des WebSockets entfernt.

Bei Pethost wurde dafür nichts eingestellt. Im Browser war die App in unter einer Sekunde gezeichnet, über wss://my-app.sam.pethost.app/_stcore/stream: „0 squared is 0“, und mit dem Slider auf 10 „10 squared is 100“. Auch der Healthcheck von Streamlit antwortet:

$ curl https://my-app.sam.pethost.app/_stcore/health
ok

pethost logs -f folgt dem, was die App ausgibt. Die „External URL“, die Streamlit dort ausgibt, ist für niemanden offen: Die Adresse ist die mit HTTPS.

Das Dockerfile, das pethost für Streamlit schreibt

Das ist die Datei, wie sie in den Ordner geschrieben wurde, vollständig:

# Written by pethost deploy for this Streamlit app: Python 3.14 (no .python-version
# names another), pip installs it (requirements.txt), streamlit_app.py is what it starts
# with.
# It is yours now: change it as you like. pethost does not write it again.

FROM python:3.14
WORKDIR /app

COPY . .

RUN --mount=type=cache,target=/root/.cache/pip \
    pip install -r requirements.txt

ENV PYTHONUNBUFFERED=1
EXPOSE 8501
CMD ["streamlit", "run", "streamlit_app.py"]

Ihre ersten Zeilen sagen, was pethost in deinem Ordner gelesen hat:

• Das Python ist 3.14, solange die .python-version kein anderes nennt.
• Die Pakete kommen aus der requirements.txt, per pip, dessen Downloads auf deiner Maschine bleiben, oder aus der uv.lock, per uv.
• Die Datei der App ist streamlit_app.py, app.py oder main.py, oder die eine andere .py-Datei im Wurzelverzeichnis, die Streamlit importiert.

Die requirements.txt muss streamlit nennen. Eine App, die für Streamlit Community Cloud gemacht ist, lässt es vielleicht weg, weil Community Cloud Streamlit selbst installiert; dann schreibt pethost kein Dockerfile. Mit der ergänzten Zeile war diese App in 30 s online.

Den Code ändern und in 3 Sekunden neu deployen

Bearbeite die App und führ denselben Befehl aus. Beim ersten Mal dauerte das 42 s: Die Datei kopiert den Ordner vor pip install, also installiert schon eine geänderte Zeile die Pakete noch einmal. Das Dockerfile gehört dir, also kopier zuerst die requirements.txt:

COPY requirements.txt .
RUN --mount=type=cache,target=/root/.cache/pip \
    pip install -r requirements.txt

COPY . .

Der Deploy, der die Datei geändert hat, dauerte 34 s. Danach überspringt eine Änderung am Code die Installation:

$ pethost deploy
my-app (.pethost)
✓ Packed 5 files · uploaded · built and started in 3 s
…
  It answers 200.
https://my-app.sam.pethost.app

Um stattdessen bei jedem Push zu deployen, verbinde das Repository einmal: pethost github sam/my-app. pethost rollback holt die vorherige Version zurück. Ein KI-Agent kann all das über den MCP-Server von Pethost erledigen: wie ein Agent ein Projekt deployt und betreut.

Eine Streamlit-App mit CSV-Datei deployen

Die meisten Streamlit-Apps zeigen Daten, oft aus einer Datei neben dem Code. Diese liest die Tabelle der Palmer Penguins einmal, behält sie mit st.cache_data und zeichnet ein Diagramm der Insel, die in einer Auswahlbox gewählt ist:

@st.cache_data
def load_data():
    return pd.read_csv("data/penguins.csv")

Mit streamlit und pandas in der requirements.txt packte derselbe Befehl die 3 Dateien, 15 KB, und die App war in 27 s online. Die CSV ging mit dem Ordner, und der Pfad, der auf deinem Laptop funktioniert, funktioniert auch auf der Maschine. Im Browser zeichnete die Wahl von Dream die Anzahl, das Diagramm und die Tabelle neu.

Die Maschine läuft immer, also bleibt, was st.cache_data behält, für den nächsten Besuch warm, und niemand wartet darauf, dass die App aufwacht. Eine Datei, die die App im Betrieb schreibt, geht verloren, wenn ein Deploy einen neuen Container erstellt. Was bleiben muss, gehört in eine Datenbank: Ein Postgres ist ein Klick, ohne Aufpreis.

Den API-Key in die .env, nicht in den Code

Ein API-Key gehört weder in den Code noch in Git. Diese App fragt die API der NASA, welche Asteroiden an einem Tag, der in einem Datumsfeld gewählt ist, an der Erde vorbeiziehen. Auf dem Laptop liest python-dotenv den Key aus der .env:

load_dotenv()  # the .env beside this file, when you run it on your laptop
…
answer = requests.get(
    "https://api.nasa.gov/neo/rest/v1/feed",
    params={"start_date": day, "end_date": day, "api_key": os.environ["NASA_API_KEY"]},
)

Die .env hat eine Zeile, NASA_API_KEY=DEMO_KEY, den Key der NASA zum Ausprobieren der API (api.nasa.gov gibt dir für einen Namen und eine E-Mail-Adresse einen eigenen). Der erste Deploy nimmt die .env mit:

$ pethost deploy
Name it [asteroids]:          it will live at https://asteroids.sam.pethost.app
✓ Packed 4 files, 863 B   (took .env from this folder)
…
✓ app listens on 8501 → https://asteroids.sam.pethost.app
  It answers 200.

Die Seite meldete 8 Asteroiden, die am 20. Oktober 2026 an der Erde vorbeiziehen, und nach dem Wechsel des Datums 10 am 21. Ab dann liegt die .env des Projekts auf der Maschine, und eine Änderung an der Datei auf deinem Laptop bleibt auf dem Laptop. Der nächste Deploy sagt das auch:

$ pethost deploy
asteroids (.pethost)
✓ Packed 6 files · uploaded · built and started in 38 s
  · kept the project's .env in place of the version's own: after the first deploy the project's is kept
…
To send this folder's .env:  pethost env push

pethost env set ändert eine Variable und deployt sofort. Ein bloßer Name, pethost env set NASA_API_KEY, fragt nach dem Wert, ohne ihn anzuzeigen. Auch Streamlit liest seine Optionen aus Variablen:

$ pethost env set STREAMLIT_BROWSER_GATHER_USAGE_STATS=false
asteroids (.pethost)
✓ /.env has STREAMLIT_BROWSER_GATHER_USAGE_STATS now. Deployed in 39 s.

Die App startete neu, ohne ihre Zeile über Nutzungsstatistiken. pethost env push schickt stattdessen deine ganze .env, nennt vorher jede Variable, die die Datei des Projekts verlieren würde, und fragt nach.

st.secrets liest die .streamlit/secrets.toml, nicht die Umgebung. Ein Ordner, der mit pethost deploy deployt wird, nimmt diese Datei mit, und st.secrets funktionierte auf der Maschine. Ein Repository sollte sie nicht enthalten, also behält eine App, die aus GitHub deployt wird, ihre Keys in der .env.

Das Dockerfile aus dem Docker-Tutorial von Streamlit deployen

Wenn du dem Tutorial „Deploy Streamlit using Docker“ von Streamlit gefolgt bist, hat dein Ordner sein Dockerfile schon. Behalte es, denn pethost deployt das eigene Dockerfile eines Ordners so, wie es ist. Hier ist das des Tutorials, mit COPY . . statt seines git clone, wie es das Tutorial für Code neben dem Dockerfile vorsieht:

FROM python:3.12-slim

WORKDIR /app

RUN apt-get update && apt-get install -y …

COPY . .

RUN pip3 install -r requirements.txt

EXPOSE 8501

HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health

ENTRYPOINT ["streamlit", "run", "streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]

$ pethost deploy
Name it [spiral]:                it will live at https://spiral.sam.pethost.app
✓ Packed 3 files, 2 KB
✓ Uploaded straight to your machine
✓ Built and started in 1 min 25 s
  · wrote compose.yaml for the Dockerfile: the service app, reading .env, port 8501
✓ app listens on 8501 → https://spiral.sam.pethost.app
  It answers 200.

Die Spirale des Tutorials zeichnete ihr Diagramm neu, sobald die Slider bewegt wurden. Sein docker run -p 8501:8501 spielt hier keine Rolle: Die Maschine findet den Port und öffnet nichts außer HTTPS. Der HEALTHCHECK läuft, und Docker meldete den Container als healthy.

Eine eigene Domain für die Streamlit-App nutzen

Jeder Name unter der Domain deines Kontos funktioniert sofort, mit HTTPS. Eine Domain, die dir gehört, ist ein Befehl, pethost domain add dashboard.example.com, der den CNAME-Eintrag ausgibt, den du anlegen musst; das Zertifikat kommt, sobald der Name auflöst.

Was du für den Preis bekommst

Pethost kostet 9,99 € im Monat für alles, was du hostest, auf 2 vCPU, 3 GB RAM und 30 GB Disk. Ein Dashboard ist selten allein: Der Job, der seine Daten füllt, seine Datenbank und deine nächste App laufen daneben, ohne Gebühr pro Projekt.

• 9,99 € im Monat für alle deine Projekte, nichts nach Verbrauch
• 52 s zum Bauen und Starten der ersten App
• 3 s für den Deploy einer Änderung an ihrem Code

Was schon für dich erledigt ist: HTTPS mit Zertifikaten, die sich selbst erneuern, Deploys aus GitHub, nächtliche Backups, 14 Tage aufbewahrt, SSH in jeden Container, und jeder Request wird gezählt, ohne ein Skript in deinen Seiten. Die Tarife stehen im Abschnitt Preise der Startseite.

Die Ausgaben stammen von Deploys auf einer Testmaschine von uns, mit pethost 0.2.4, Streamlit 1.66.1 und Python 3.14.9 (3.12.15 im Dockerfile des Tutorials). Das Projekt my-app wurde zuerst deployt; die Apps mit CSV und mit API-Key fanden das Image von Python 3.14 schon auf der Maschine vor. Das Konto darin ist das Beispielkonto, sam.

1. Streamlit: Streamlit über die Kommandozeile installieren
2. Streamlit: Grundkonzepte
3. Streamlit: Streamlit mit Docker deployen
4. Streamlit: Die App lädt nicht, wenn sie remote läuft
5. Streamlit: Verwaltung von Secrets
6. Streamlit: Abhängigkeiten einer App für Community Cloud
7. NASA: offene APIs
8. Palmer Penguins: die Daten
9. pethost, die Kommandozeile von Pethost