---
title: "Comment déployer une application Streamlit en 2026 "
description: "Déployez une application Streamlit en une commande : pethost deploy écrit le Dockerfile, lance streamlit run et la sert en HTTPS, pour 9,99 € par mois."
---

[Blog](https://pethost.dev/fr/blog/) · Guides de déploiement

# Comment déployer une application Streamlit en 2026 : une commande, HTTPS et un Dockerfile qui reste à vous

Par l’équipe Pethost · 25 octobre 2026 · 11 min de lecture

Vous avez une application Streamlit qui tourne avec `streamlit run` sur votre ordinateur, et vous voulez la mettre en ligne à une adresse en HTTPS, pour des gens qui n’ont pas Python. Sur Pethost, c’est une seule commande, `pethost deploy`, lancée dans le dossier qui contient `requirements.txt`. Elle écrit le Dockerfile, construit l’application sur votre machine Pethost et affiche son adresse. L’application des premières pages de la documentation de Streamlit a été en ligne en 52 secondes, et une modification de son code, plus tard, en 3.

**En bref**

- **Une commande :** `pethost deploy` dans le dossier qui contient `requirements.txt`. Ni fichier de configuration, ni port à ouvrir, ni Docker sur votre ordinateur.
- **Ce qu’elle fait :** elle écrit un Dockerfile qui installe vos paquets et lance `streamlit run streamlit_app.py`, et dirige l’adresse vers le port 8501.
- **Les widgets fonctionnent :** le WebSocket de Streamlit passe par le proxy de Pethost, sans rien à régler.
- **Les clés d’API** vont dans `.env`, que le premier déploiement emporte avec lui ; `pethost env set` change une clé par la suite.
- **Le prix :** 9,99 € par mois pour 2 vCPU, 3 GB et 30 GB, pour tous vos projets. Il n’y a pas d’offre gratuite.

## Ce qu’il faut pour déployer une application Streamlit en 2026

Trois choses : l’application, la commande `pethost` et un compte Pethost.

**L’application** est ici celle par laquelle commence la documentation de Streamlit. Son guide d’installation crée un environnement virtuel dans le dossier du projet et y installe Streamlit :

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

Puis `streamlit_app.py`, avec le slider de la première leçon de Streamlit :

```
import streamlit as st

st.title("My app")

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

Et `requirements.txt`, la liste de ce que l’application installe, avec une seule ligne : `streamlit`.

**La commande** est un seul programme, installé en une ligne. Toutes ses commandes sont dans la [référence de la 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
```

**Le compte** a besoin d’une offre. Si vous n’êtes pas connecté, `pethost deploy` ouvre votre navigateur et vous connecte. Si vous n’avez pas encore d’offre, elle vous montre où en choisir une, et attend.

## Déployer l’application Streamlit en une commande

Allez dans le dossier qui contient `requirements.txt` et lancez `pethost deploy`. Voici l’écran entier :

```
$ 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. **Elle demande une seule chose** Le nom du projet, le premier mot de son adresse. Entrée prend le nom du dossier.
2. **Elle laisse l’environnement virtuel de côté** `.venv` contenait 450 MB de paquets, que la machine installe elle-même.
3. **La machine ne trouve rien à lancer** La ligne avec la croix : le dossier n’a encore ni Dockerfile ni fichier Compose.
4. **pethost écrit le Dockerfile** `requirements.txt` nomme `streamlit` : pethost écrit donc celui de Streamlit et envoie à nouveau le dossier.
5. **La machine le construit et le démarre** Elle voit l’application écouter sur 8501, y dirige l’adresse HTTPS, et pethost affiche la réponse : 200.

Le fichier `.pethost` indique à quel projet correspond ce dossier. Commitez-le avec le Dockerfile, et le déploiement suivant ne demande plus rien.

## Ouvrir l’application : les widgets et le WebSocket

Une page Streamlit joint l’application par un WebSocket, `/_stcore/stream` : chaque widget que vous bougez passe par lui, et le script s’exécute à nouveau sur le serveur. Quand cela échoue, la page affiche son squelette de chargement indéfiniment ; la base de connaissances de Streamlit en accuse CORS, ou un proxy qui enlève les en-têtes du WebSocket.

Sur Pethost, rien n’a été réglé pour cela. Dans un navigateur, l’application s’est affichée en moins d’une seconde, par `wss://my-app.sam.pethost.app/_stcore/stream` : « 0 squared is 0 », et avec le slider poussé à 10, « 10 squared is 100 ». Le health check de Streamlit répond aussi :

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

`pethost logs -f` suit ce que l’application affiche. L’« External URL » que Streamlit y affiche n’est ouverte à personne : l’adresse, c’est celle en HTTPS.

## Le Dockerfile que pethost écrit pour Streamlit

Voici le fichier tel qu’il a été écrit dans le dossier, en entier :

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

Ses premières lignes disent ce que pethost a lu dans votre dossier :

- **Le Python** est le 3.14, sauf si `.python-version` en nomme un autre.
- **Les paquets** viennent de `requirements.txt` par pip, dont les téléchargements restent sur votre machine, ou de `uv.lock` par uv.
- **Le fichier de l’application** est `streamlit_app.py`, `app.py` ou `main.py`, ou bien l’unique autre fichier `.py` à la racine qui importe Streamlit.

`requirements.txt` doit nommer `streamlit`. Une application faite pour Streamlit Community Cloud peut l’omettre, puisque Community Cloud installe Streamlit lui-même ; pethost n’écrit alors aucun Dockerfile. Une fois la ligne ajoutée, cette application a été en ligne en 30 secondes.

## Modifier le code et redéployer en 3 secondes

Modifiez l’application et lancez la même commande. La première fois, cela a pris 42 secondes : le fichier copie le dossier avant `pip install`, donc une seule ligne modifiée réinstalle les paquets. Le Dockerfile est à vous : copiez donc d’abord `requirements.txt` :

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

COPY . .
```

Le déploiement qui a modifié le fichier a pris 34 secondes. Ensuite, une modification du code saute l’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
```

Pour déployer plutôt à chaque push, connectez le dépôt une fois : `pethost github sam/my-app`. `pethost rollback` remet en place la version précédente. Un agent IA peut faire tout cela par le serveur MCP de Pethost : [comment un agent déploie un projet et s’en occupe](https://pethost.dev/fr/blog/hosting-for-ai-coding-agents/).

## Déployer une application Streamlit qui lit un CSV

La plupart des applications Streamlit montrent des données, souvent un fichier placé à côté du code. Celle-ci lit une fois la table des manchots de Palmer, la garde avec `st.cache_data`, et trace le graphique de l’île choisie dans une liste déroulante :

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

Avec `streamlit` et `pandas` dans `requirements.txt`, la même commande a empaqueté ses 3 fichiers, 15 KB, et l’application a été en ligne en 27 secondes. Le CSV est parti avec le dossier, et le chemin qui fonctionne sur votre ordinateur fonctionne sur la machine. Dans le navigateur, choisir Dream a redessiné le décompte, le graphique et le tableau.

La machine est toujours allumée : ce que garde `st.cache_data` reste prêt pour le visiteur suivant, et personne [n’attend que l’application se réveille](https://pethost.dev/fr/blog/always-on-hosting-no-cold-starts/). Un fichier que l’application écrit pendant qu’elle tourne est perdu quand un déploiement crée un nouveau conteneur. Gardez ce qui doit durer dans une base de données : une base Postgres, c’est un clic, [sans coût supplémentaire](https://pethost.dev/fr/blog/european-hosting-postgres-flat-price/).

## Garder la clé d’API dans .env, pas dans le code

Une clé d’API n’a sa place ni dans le code ni dans Git. Cette application demande à l’API de la NASA quels astéroïdes passent près de la Terre le jour choisi dans un sélecteur de date. Sur votre ordinateur, `python-dotenv` lit la clé dans `.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` a une seule ligne, `NASA_API_KEY=DEMO_KEY`, la clé que la NASA donne pour essayer son API (api.nasa.gov vous donne la vôtre contre un nom et une adresse e-mail). Le premier déploiement emporte `.env` avec lui :

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

La page a indiqué 8 astéroïdes passant près de la Terre le 20 octobre 2026, et 10 le 21 une fois la date changée. Dès lors, le `.env` du projet vit sur la machine, et une modification du fichier sur votre ordinateur reste sur votre ordinateur. Le déploiement suivant le signale :

```
$ 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` change une variable et déploie aussitôt. Avec un nom seul, `pethost env set NASA_API_KEY` demande la valeur sans l’afficher. Streamlit lit aussi ses options dans des variables :

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

L’application a redémarré sans sa ligne sur les statistiques d’utilisation. `pethost env push` envoie plutôt votre `.env` entier, après avoir nommé chaque variable que le fichier du projet perdrait, et demande confirmation.

`st.secrets` lit `.streamlit/secrets.toml`, pas l’environnement. Un dossier déployé avec `pethost deploy` emporte ce fichier, et `st.secrets` a fonctionné sur la machine. Un dépôt ne devrait pas le contenir : une application déployée depuis GitHub garde donc ses clés dans `.env`.

## Déployer le Dockerfile du tutoriel Docker de Streamlit

Si vous avez suivi le tutoriel de Streamlit « Deploy Streamlit using Docker », votre dossier a déjà son Dockerfile. Gardez-le : pethost déploie tel quel le Dockerfile d’un dossier. Voici celui du tutoriel, avec `COPY . .` à la place de son `git clone`, comme le tutoriel l’indique pour du code placé à côté du 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.
```

La spirale du tutoriel a redessiné son graphique à mesure que les sliders bougeaient. Son `docker run -p 8501:8501` n’a pas lieu d’être ici : la machine trouve le port et n’ouvre rien d’autre que HTTPS. Le `HEALTHCHECK` s’exécute, et Docker a déclaré le conteneur sain.

## Utiliser votre propre domaine pour l’application Streamlit

Chaque nom sous le domaine de votre compte fonctionne aussitôt, en HTTPS. Un domaine à vous, c’est une commande, `pethost domain add dashboard.example.com`, qui affiche l’enregistrement CNAME à créer ; le certificat arrive dès que le nom se résout.

## Ce que vous obtenez pour ce prix

Pethost coûte 9,99 € par mois pour tout ce que vous hébergez, sur 2 vCPU, 3 GB de mémoire et 30 GB de disque. Un tableau de bord est rarement seul : la tâche qui remplit ses données, sa base de données et votre prochaine application tournent à côté, [sans frais par projet](https://pethost.dev/fr/blog/unlimited-projects-flat-monthly-fee/).

- **9,99 €** par mois pour tous vos projets, rien à l’usage
- **52 s** pour construire et démarrer la première application
- **3 s** pour déployer une modification de son code

Ce qui est déjà fait pour vous : HTTPS avec des certificats qui se renouvellent tout seuls, les déploiements depuis GitHub, des sauvegardes chaque nuit conservées 14 jours, SSH dans n’importe quel conteneur, et chaque requête comptée, sans script dans vos pages. Les offres sont dans la partie [tarifs](https://pethost.dev/fr/#pricing) de la première page.

**Chaque projet, bien identifié.** Sept projets sur une seule machine Starter : les applications avec leurs adresses et leurs requêtes du dernier jour, les bases de données avec les applications qui les utilisent.

![La première page de la console Pethost : le CPU, la mémoire et le disque de la machine, et ses projets sous forme de cartes.](https://pethost.dev/shots/projects.webp)

### Pethost est le meilleur choix pour

- **Les profils data avec une application Streamlit** à partager avec des collègues ou des clients, à une adresse bien à eux
- **Les développeurs solo** qui ont plusieurs tableaux de bord, bots et projets perso, et une seule facture à payer
- **Ceux dont l’agent déploie à leur place** : Claude Code ou Codex met l’application en ligne et lit ses logs
- **Les jeunes startups** qui veulent un coût mensuel fixe tant que le produit est petit

### Cherchez ailleurs si

- Votre application a besoin de plusieurs régions ou d’autoscaling

## Questions

### Comment déployer une application Streamlit sans écrire de Dockerfile ?

Lancez `pethost deploy` dans le dossier qui contient `requirements.txt`. Elle écrit le Dockerfile qui lance `streamlit run` et le déploie ; le fichier reste dans votre dossier, à vous de le modifier.

### Pourquoi mon application Streamlit déployée ne finit jamais de charger ?

La page joint l’application par un WebSocket sur `/_stcore/stream`, et quand cela échoue, elle affiche son squelette de chargement indéfiniment. Sur Pethost, le WebSocket passe par le proxy sans rien à régler.

### Quel port utilise une application Streamlit sur Pethost ?

Celui de Streamlit, 8501. La machine trouve le port sur lequel l’application écoute et y dirige l’adresse HTTPS : vous n’ouvrez rien.

### Où mettre les clés d’API d’une application Streamlit déployée ?

Dans le `.env` du projet, que le premier déploiement prend dans votre dossier ; `pethost env set NAME` change une clé sans l’afficher, et l’application lit `os.environ`. `st.secrets` fonctionne pour un dossier déployé avec son `secrets.toml`.

### Combien coûte l’hébergement d’une application Streamlit sur Pethost ?

9,99 € par mois pour Starter, avec 2 vCPU, 3 GB et 30 GB, sans frais par projet : vos autres applications et bases de données y tournent aussi. Il n’y a pas d’offre gratuite. Les prix sont hors TVA.

Les écrans sont des déploiements sur une de nos machines de test, avec pethost 0.2.4, Streamlit 1.66.1 et Python 3.14.9 (3.12.15 dans le Dockerfile du tutoriel). `my-app` a été déployée en premier ; les applications du CSV et de la clé d’API ont trouvé l’image de Python 3.14 déjà sur la machine. Le compte qu’on y voit est celui de l’exemple, `sam`.

1. [Streamlit : installer Streamlit en ligne de commande](https://docs.streamlit.io/get-started/installation/command-line)
2. [Streamlit : les concepts de base](https://docs.streamlit.io/get-started/fundamentals/main-concepts)
3. [Streamlit : déployer Streamlit avec Docker](https://docs.streamlit.io/deploy/tutorials/docker)
4. [Streamlit : l’application ne se charge pas quand elle tourne à distance](https://docs.streamlit.io/knowledge-base/deploy/remote-start)
5. [Streamlit : la gestion des secrets](https://docs.streamlit.io/develop/concepts/connections/secrets-management)
6. [Streamlit : les dépendances d’une application sur Community Cloud](https://docs.streamlit.io/deploy/streamlit-community-cloud/deploy-your-app/app-dependencies)
7. [NASA : les API ouvertes](https://api.nasa.gov/)
8. [Palmer penguins : les données](https://allisonhorst.github.io/palmerpenguins/)
9. [pethost, la ligne de commande de Pethost](https://pethost.dev/docs/cli/)

## Mettez vos projets en ligne dès aujourd’hui

Déployez applications, bots et bases de données depuis votre agent, GitHub ou le navigateur, autant qu’il en tient, à un prix fixe. Rien au compteur, rien facturé en plus.

[Tout héberger pour 9,99 €/mois](https://console.pethost.dev/)

## Continuer la lecture

- 24 octobre 2026 [Comment déployer une application PHP en 2026 : Laravel, Symfony ou pages PHP simples en une commande](https://pethost.dev/fr/blog/deploy-php-app/) Déployez une application PHP en une commande : pethost deploy écrit le Dockerfile pour Laravel, Symfony ou des pages PHP et la sert en HTTPS, pour 9,99 €/mois.
- 10 octobre 2026 [Comment déployer une application Gin en 2026 : une commande, HTTPS et un Dockerfile qui reste à vous](https://pethost.dev/fr/blog/deploy-gin-app/) Déployez une application Go Gin en une commande : pethost deploy écrit le Dockerfile, construit le programme et le sert en HTTPS, pour 9,99 € par mois.
- 10 octobre 2026 [Comment déployer une application Go Fiber en 2026 : une commande, HTTPS et un Dockerfile qui reste à vous](https://pethost.dev/fr/blog/deploy-fiber-app/) Déployez une application Go Fiber en une commande : pethost deploy écrit le Dockerfile, la construit en 45 s et la sert en HTTPS, pour 9,99 € par mois.
- 10 octobre 2026 [Comment déployer une application Nuxt en 2026 : une commande, un serveur Node et HTTPS](https://pethost.dev/fr/blog/deploy-nuxt-app/) Déployez une application Nuxt 4 en une commande : pethost deploy écrit le Dockerfile, lance nuxt build et démarre le serveur Node en HTTPS, pour 9,99 €/mois.

[Tous les articles](https://pethost.dev/fr/blog/) · [À propos de Pethost](https://pethost.dev/about/) · [Tarifs](https://pethost.dev/fr/#pricing)

Pethost · Stephan Gomer · NIP 1133096755

Pethost

- [Templates](https://pethost.dev/fr/templates/)
- [À propos](https://pethost.dev/about/)
- [Docs](https://pethost.dev/docs/)
- [Blog](https://pethost.dev/fr/blog/)
- [API](https://pethost.dev/docs/api/)
- [CLI](https://pethost.dev/docs/cli/)
- [Plugin](https://github.com/pethost-dev/plugin)
- [Conditions](https://pethost.dev/terms/)
- [Confidentialité](https://pethost.dev/privacy/)
- [Remboursements](https://pethost.dev/refunds/)
- [support@pethost.dev](mailto:support@pethost.dev)

Bases de données

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

Comparatifs

- [Coolify vs Dokploy vs CapRover vs Dokku](https://pethost.dev/fr/blog/coolify-vs-dokploy-vs-caprover-vs-dokku/)
- [Coolify Cloud vs Dokploy Cloud](https://pethost.dev/fr/blog/coolify-cloud-vs-dokploy-cloud/)
- [Tarifs Railway vs Render vs Fly.io](https://pethost.dev/fr/blog/railway-vs-render-vs-fly-io-pricing/)
- [Hébergement Docker Compose managé](https://pethost.dev/fr/blog/managed-docker-compose-hosting/)

Alternatives

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