---
title: "Jak wdrożyć aplikację Streamlit w 2026"
description: "Wdróż aplikację Streamlit jednym poleceniem: pethost deploy pisze Dockerfile, uruchamia streamlit run i serwuje aplikację przez HTTPS za 9,99 €/mies."
---

[Blog](https://pethost.dev/pl/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.

**W skrócie**

- **Jedno polecenie:** `pethost deploy` w katalogu z `requirements.txt`. Bez pliku konfiguracyjnego, bez portu do otwierania, bez Dockera na laptopie.
- **Co robi:** pisze Dockerfile, który instaluje twoje pakiety i uruchamia `streamlit run streamlit_app.py`, a adres kieruje na port 8501.
- **Widżety działają:** WebSocket Streamlita przechodzi przez proxy Pethost, bez żadnych ustawień.
- **Klucze API** trafiają do `.env`, który pierwsze wdrożenie zabiera ze sobą; `pethost env set` zmienia klucz później.
- **Cena:** 9,99 € miesięcznie za 2 vCPU, 3 GB i 30 GB, na każdy twój projekt. Nie ma darmowego planu.

## 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](https://pethost.dev/docs/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](https://pethost.dev/pl/blog/hosting-for-ai-coding-agents/).

## 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](https://pethost.dev/pl/blog/always-on-hosting-no-cold-starts/). 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](https://pethost.dev/pl/blog/european-hosting-postgres-flat-price/).

## 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](https://pethost.dev/pl/blog/unlimited-projects-flat-monthly-fee/).

- **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](https://pethost.dev/pl/#pricing) na stronie głównej.

**Każdy projekt opisany.** Siedem projektów na jednej maszynie Starter: aplikacje z adresami i żądaniami z ostatniej doby, bazy danych z aplikacjami, które z nich korzystają.

![Pierwsza strona panelu Pethost: CPU, pamięć i dysk maszyny oraz jej projekty jako karty.](https://pethost.dev/shots/projects.webp)

### Pethost to najlepszy wybór dla

- **Analityków danych z aplikacją Streamlit**, którą chcą pokazać współpracownikom albo klientom pod jej własnym adresem
- **Solo developerów** z kilkoma dashboardami, botami i projektami pobocznymi oraz jednym rachunkiem do zapłacenia
- **Ludzi, za których wdraża agent**: Claude Code albo Codex wystawia aplikację w sieci i czyta jej logi
- **Wczesnych startupów**, które chcą stałego miesięcznego kosztu, dopóki produkt jest mały

### Szukaj gdzie indziej, jeśli

- Twoja aplikacja potrzebuje kilku regionów albo autoskalowania

## Pytania

### Jak wdrożyć aplikację Streamlit bez pisania Dockerfile?

Uruchom `pethost deploy` w katalogu z `requirements.txt`. Pisze Dockerfile, który uruchamia `streamlit run`, i go wdraża; plik zostaje w twoim katalogu i możesz go zmieniać.

### Dlaczego wdrożona aplikacja Streamlit ciągle się ładuje?

Strona łączy się z aplikacją przez WebSocket pod `/_stcore/stream`, a gdy to zawodzi, bez końca pokazuje szkielet ładowania. Na Pethost WebSocket przechodzi przez proxy bez żadnych ustawień.

### Jakiego portu używa aplikacja Streamlit na Pethost?

Własnego portu Streamlita, 8501. Maszyna znajduje port, na którym nasłuchuje aplikacja, i kieruje tam adres HTTPS: niczego nie otwierasz.

### Gdzie trzymać klucze API wdrożonej aplikacji Streamlit?

W `.env` projektu, który pierwsze wdrożenie bierze z twojego katalogu; `pethost env set NAME` zmienia klucz, nie pokazując go, a aplikacja czyta `os.environ`. `st.secrets` działa w katalogu wdrożonym razem z jego `secrets.toml`.

### Ile kosztuje hosting aplikacji Streamlit na Pethost?

9,99 € miesięcznie za plan Starter, z 2 vCPU, 3 GB i 30 GB, bez opłaty za projekt: twoje inne aplikacje i bazy danych też tam działają. Nie ma darmowego planu. Ceny są bez VAT.

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ń](https://docs.streamlit.io/get-started/installation/command-line)
2. [Streamlit: podstawowe pojęcia](https://docs.streamlit.io/get-started/fundamentals/main-concepts)
3. [Streamlit: wdrażanie Streamlita z Dockerem](https://docs.streamlit.io/deploy/tutorials/docker)
4. [Streamlit: aplikacja nie ładuje się po zdalnym uruchomieniu](https://docs.streamlit.io/knowledge-base/deploy/remote-start)
5. [Streamlit: zarządzanie sekretami](https://docs.streamlit.io/develop/concepts/connections/secrets-management)
6. [Streamlit: zależności aplikacji w Community Cloud](https://docs.streamlit.io/deploy/streamlit-community-cloud/deploy-your-app/app-dependencies)
7. [NASA: otwarte API](https://api.nasa.gov/)
8. [Palmer penguins: dane](https://allisonhorst.github.io/palmerpenguins/)
9. [pethost, narzędzie wiersza poleceń Pethost](https://pethost.dev/docs/cli/)

## Opublikuj swoje projekty jeszcze dziś

Wdrażaj aplikacje, boty i bazy danych ze swojego agenta, z GitHuba lub w przeglądarce, tyle, ile się zmieści, w jednej stałej cenie. Nic liczonego za zużycie, nic doliczanego.

[Hostuj wszystko za 9,99 €/mies.](https://console.pethost.dev/)

## Czytaj dalej

- 24 października 2026 [Jak wdrożyć aplikację PHP w 2026: Laravel, Symfony albo zwykłe strony PHP jednym poleceniem](https://pethost.dev/pl/blog/deploy-php-app/) Wdróż aplikację PHP jednym poleceniem: pethost deploy pisze Dockerfile dla Laravela, Symfony lub zwykłych stron PHP i serwuje ją przez HTTPS za 9,99 €/mies.
- 10 października 2026 [Jak wdrożyć aplikację Gin w 2026: jedno polecenie, HTTPS i Dockerfile, który zostaje u ciebie](https://pethost.dev/pl/blog/deploy-gin-app/) Wdróż aplikację Go Gin jednym poleceniem: pethost deploy pisze Dockerfile, buduje program i serwuje go przez HTTPS za 9,99 € miesięcznie.
- 10 października 2026 [Jak wdrożyć aplikację Go Fiber w 2026: jedno polecenie, HTTPS i Dockerfile, który zostaje u ciebie](https://pethost.dev/pl/blog/deploy-fiber-app/) Wdróż aplikację Go Fiber jednym poleceniem: pethost deploy pisze Dockerfile, buduje ją w 45 sekund i serwuje przez HTTPS za 9,99 € miesięcznie.
- 10 października 2026 [Jak wdrożyć aplikację Nuxt w 2026: jedno polecenie, serwer Node i HTTPS](https://pethost.dev/pl/blog/deploy-nuxt-app/) Wdróż aplikację Nuxt 4 jednym poleceniem: pethost deploy pisze Dockerfile, uruchamia nuxt build i startuje serwer Node z HTTPS za 9,99 € miesięcznie.

[Wszystkie artykuły](https://pethost.dev/pl/blog/) · [O Pethost](https://pethost.dev/about/) · [Cennik](https://pethost.dev/pl/#pricing)

Pethost · Stephan Gomer · NIP 1133096755

Pethost

- [Szablony](https://pethost.dev/pl/templates/)
- [O nas](https://pethost.dev/about/)
- [Dokumentacja](https://pethost.dev/docs/)
- [Blog](https://pethost.dev/pl/blog/)
- [API](https://pethost.dev/docs/api/)
- [CLI](https://pethost.dev/docs/cli/)
- [Plugin](https://github.com/pethost-dev/plugin)
- [Regulamin](https://pethost.dev/terms/)
- [Prywatność](https://pethost.dev/privacy/)
- [Zwroty](https://pethost.dev/refunds/)
- [support@pethost.dev](mailto:support@pethost.dev)

Bazy danych

- [Postgres](https://pethost.dev/pl/postgres/)

Porównania

- [Coolify vs Dokploy vs CapRover vs Dokku](https://pethost.dev/pl/blog/coolify-vs-dokploy-vs-caprover-vs-dokku/)
- [Coolify Cloud vs Dokploy Cloud](https://pethost.dev/pl/blog/coolify-cloud-vs-dokploy-cloud/)
- [Cennik Railway vs Render vs Fly.io](https://pethost.dev/pl/blog/railway-vs-render-vs-fly-io-pricing/)
- [Zarządzany hosting Docker Compose](https://pethost.dev/pl/blog/managed-docker-compose-hosting/)

Alternatywy

- [Alternatywy dla Railway](https://pethost.dev/pl/blog/railway-alternatives/)
- [Alternatywy dla Heroku](https://pethost.dev/pl/blog/heroku-alternatives/)
- [Alternatywy dla Dokploy](https://pethost.dev/pl/blog/dokploy-alternatives/)
- [Alternatywy dla Coolify](https://pethost.dev/pl/blog/coolify-alternatives/)
- [Alternatywy dla Render](https://pethost.dev/pl/blog/render-alternatives/)
- [Alternatywy dla Sliplane](https://pethost.dev/pl/blog/sliplane-alternatives/)