Blog · Poradniki wdrożeń

Jak wdrożyć aplikację Streamlit w 2026: jedno polecenie, HTTPS i Dockerfile, który zostaje twój

Zespół Pethost · 25 października 2026 · 10 min czytania

Masz aplikację Streamlit, która działa na twoim laptopie przez streamlit run, i chcesz ją mieć w sieci pod adresem z HTTPS, dla ludzi, którzy nie mają Pythona. Na Pethost to jedno polecenie, pethost deploy, uruchomione w katalogu z requirements.txt. Samo pisze Dockerfile, buduje aplikację na twojej maszynie Pethost i wypisuje jej adres. Aplikacja z pierwszych stron dokumentacji Streamlita była w sieci po 52 sekundach, a późniejsza zmiana jej kodu po 3.

Czego potrzebujesz, żeby wdrożyć aplikację Streamlit w 2026

Trzech rzeczy: aplikacji, polecenia pethost i konta Pethost.

Aplikacja to tutaj ta, od której zaczyna dokumentacja Streamlita. Jej przewodnik instalacji tworzy środowisko wirtualne w katalogu projektu i instaluje w nim Streamlit:

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

Potem streamlit_app.py, z suwakiem z pierwszej lekcji Streamlita:

import streamlit as st

st.title("My app")

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

I requirements.txt, lista tego, co aplikacja instaluje, z jedną linią: streamlit.

Polecenie to jeden program, instalowany jedną linią. Wszystkie jego polecenia są w dokumentacji CLI.

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

Konto potrzebuje planu. Jeśli nie jesteś zalogowany, pethost deploy otwiera przeglądarkę i cię loguje. Jeśli nie masz jeszcze planu, pokazuje, gdzie go wybrać, i czeka.

Wdróż aplikację Streamlit jednym poleceniem

Przejdź do katalogu z requirements.txt i uruchom pethost deploy. Oto cały ekran:

$ 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. Pyta o jedno O nazwę projektu, która jest pierwszym słowem jego adresu. Enter bierze nazwę katalogu.
2. Pomija środowisko wirtualne .venv zajmował 450 MB pakietów, które maszyna instaluje sama.
3. Maszyna nie znajduje nic do uruchomienia Linia z krzyżykiem: w katalogu nie ma jeszcze Dockerfile ani pliku Compose.
4. pethost pisze Dockerfile requirements.txt wymienia streamlit, więc pisze Dockerfile dla Streamlita i wgrywa katalog jeszcze raz.
5. Maszyna buduje i uruchamia aplikację Widzi, że aplikacja nasłuchuje na 8501, kieruje tam adres HTTPS, a pethost wypisuje odpowiedź: 200.

Plik .pethost mówi, którym projektem jest ten katalog. Zrób jego commit razem z Dockerfile, a następne wdrożenie o nic nie zapyta.

Otwórz aplikację: widżety i WebSocket

Strona Streamlita łączy się z aplikacją przez WebSocket, /_stcore/stream: każdy ruch widżetu idzie tą drogą, a skrypt uruchamia się ponownie na serwerze. Gdy to zawodzi, strona bez końca pokazuje szkielet ładowania; baza wiedzy Streamlita wini za to CORS albo proxy, które obcina nagłówki WebSocketu.

Na Pethost nie trzeba było nic ustawiać. W przeglądarce aplikacja narysowała się w niecałą sekundę, przez wss://my-app.sam.pethost.app/_stcore/stream: „0 squared is 0”, a po przesunięciu suwaka na 10 „10 squared is 100”. Health check Streamlita też odpowiada:

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

pethost logs -f śledzi to, co wypisuje aplikacja. „External URL”, który Streamlit tam wypisuje, nie jest dla nikogo otwarty: adresem jest ten z HTTPS.

Dockerfile, który pethost pisze dla Streamlita

Oto plik w całości, tak jak został zapisany w katalogu:

# 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"]

Jego pierwsze linie mówią, co pethost odczytał w twoim katalogu:

• Python to 3.14, chyba że .python-version wskazuje inną wersję.
• Pakiety instaluje pip z requirements.txt, a pobrane przez niego pliki zostają na twojej maszynie, albo uv z uv.lock.
• Plik aplikacji to streamlit_app.py, app.py albo main.py, albo jedyny inny plik .py w katalogu głównym, który importuje Streamlit.

requirements.txt musi wymieniać streamlit. Aplikacja zrobiona dla Streamlit Community Cloud może go pomijać, bo Community Cloud sam instaluje Streamlit; wtedy pethost nie pisze Dockerfile. Po dopisaniu tej linii taka aplikacja była w sieci po 30 sekundach.

Zmień kod i wdróż ponownie w 3 sekundy

Zmień aplikację i uruchom to samo polecenie. Za pierwszym razem trwało to 42 sekundy: plik kopiuje katalog przed pip install, więc jedna zmieniona linia instaluje pakiety od nowa. Dockerfile jest twój, więc kopiuj najpierw requirements.txt:

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

COPY . .

Wdrożenie, które zmieniło plik, trwało 34 sekundy. Po nim zmiana kodu pomija instalację:

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

Żeby zamiast tego wdrażać każdy push, podłącz raz repozytorium: pethost github sam/my-app. pethost rollback przywraca poprzednią wersję. Agent AI może zrobić to wszystko przez serwer MCP Pethost: jak agent wdraża projekt i się nim opiekuje.

Wdróż aplikację Streamlit, która czyta plik CSV

Większość aplikacji Streamlit pokazuje dane, często z pliku obok kodu. Ta raz czyta tabelę pingwinów Palmer, trzyma ją dzięki st.cache_data i rysuje wykres dla wyspy wybranej z listy:

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

Z streamlit i pandas w requirements.txt to samo polecenie spakowało 3 pliki, 15 KB, a aplikacja była w sieci po 27 sekundach. CSV pojechał razem z katalogiem, a ścieżka, która działa na laptopie, działa też na maszynie. W przeglądarce wybór Dream przerysował liczebność, wykres i tabelę.

Maszyna działa zawsze, więc to, co trzyma st.cache_data, zostaje ciepłe dla następnego odwiedzającego i nikt nie czeka, aż aplikacja się obudzi. Plik, który aplikacja zapisuje w trakcie działania, przepada, gdy wdrożenie tworzy nowy kontener. To, co ma przetrwać, trzymaj w bazie danych: Postgres to jedno kliknięcie, bez dodatkowych kosztów.

Trzymaj klucz API w .env, nie w kodzie

Klucz API nie powinien być ani w kodzie, ani w Gicie. Ta aplikacja pyta API NASA, które asteroidy mijają Ziemię w dniu wybranym w polu daty. Na laptopie python-dotenv czyta klucz z .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"]},
)

.env ma jedną linię, NASA_API_KEY=DEMO_KEY, klucz NASA do wypróbowania API (na api.nasa.gov dostaniesz własny za imię i e-mail). Pierwsze wdrożenie zabiera .env ze sobą:

$ 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.

Strona podała, że 20 października 2026 Ziemię mija 8 asteroid, a po zmianie daty na 21 października – 10. Od tej chwili .env projektu mieszka na maszynie, a zmiana pliku na twoim laptopie zostaje na laptopie. Następne wdrożenie to mówi:

$ 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 zmienia jedną zmienną i od razu wdraża. Sama nazwa, pethost env set NASA_API_KEY, pyta o wartość, nie pokazując jej. Streamlit też czyta swoje opcje ze zmiennych:

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

Aplikacja uruchomiła się ponownie już bez swojej linii o statystykach użycia. pethost env push wysyła zamiast tego cały twój .env, ale najpierw wymienia każdą zmienną, którą plik projektu by stracił, i pyta.

st.secrets czyta .streamlit/secrets.toml, nie zmienne środowiskowe. Katalog wdrożony przez pethost deploy zabiera ten plik ze sobą i st.secrets działało na maszynie. Repozytorium nie powinno go zawierać, więc aplikacja wdrażana z GitHuba trzyma klucze w .env.

Wdróż Dockerfile z tutorialu Streamlita o Dockerze

Jeśli twój katalog powstał według tutorialu Streamlita „Wdrażanie Streamlita z Dockerem”, ma już jego Dockerfile. Zostaw go: pethost wdraża Dockerfile z katalogu tak, jak jest. Oto ten z tutorialu, z COPY . . zamiast jego git clone, jak tutorial radzi dla kodu leżącego obok Dockerfile:

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.

Spirala z tutorialu przerysowywała wykres, gdy przesuwały się suwaki. Jego docker run -p 8501:8501 nie ma tu zastosowania: maszyna sama znajduje port i nie otwiera nic poza HTTPS. HEALTHCHECK działa, a Docker uznał kontener za zdrowy.

Użyj własnej domeny dla aplikacji Streamlit

Każda nazwa pod domeną twojego konta działa od razu, z HTTPS. Domena, którą masz, to jedno polecenie, pethost domain add dashboard.example.com, które wypisuje rekord CNAME do utworzenia; certyfikat przychodzi, gdy tylko nazwa zaczyna się rozwiązywać.

Co dostajesz za tę cenę

Pethost kosztuje 9,99 € miesięcznie za wszystko, co hostujesz, na 2 vCPU, 3 GB pamięci i 30 GB dysku. Dashboard rzadko jest sam: zadanie, które zasila go danymi, jego baza danych i twoja następna aplikacja działają obok, bez opłaty za projekt.

• 9,99 € miesięcznie za wszystkie twoje projekty, nic nie jest liczone od zużycia
• 52 s na zbudowanie i uruchomienie pierwszej aplikacji
• 3 s na wdrożenie zmiany jej kodu

Co jest już zrobione za ciebie: HTTPS z certyfikatami, które same się odnawiają, wdrożenia z GitHuba, nocne backupy trzymane przez 14 dni, SSH do każdego kontenera i każde żądanie policzone, bez żadnego skryptu na twoich stronach. Plany są w cenniku na stronie głównej.

Ekrany to wdrożenia na naszej maszynie testowej, z pethost 0.2.4, Streamlit 1.66.1 i Pythonem 3.14.9 (3.12.15 w Dockerfile z tutorialu). my-app został wdrożony pierwszy; aplikacje z CSV i z kluczem API zastały obraz Pythona 3.14 już na maszynie. Konto na nich to przykładowe sam.

1. Streamlit: instalacja Streamlita z wiersza poleceń
2. Streamlit: podstawowe pojęcia
3. Streamlit: wdrażanie Streamlita z Dockerem
4. Streamlit: aplikacja nie ładuje się po zdalnym uruchomieniu
5. Streamlit: zarządzanie sekretami
6. Streamlit: zależności aplikacji w Community Cloud
7. NASA: otwarte API
8. Palmer penguins: dane
9. pethost, narzędzie wiersza poleceń Pethost