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.

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.

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.

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

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.

• 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 de la première page.

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
2. Streamlit : les concepts de base
3. Streamlit : déployer Streamlit avec Docker
4. Streamlit : l’application ne se charge pas quand elle tourne à distance
5. Streamlit : la gestion des secrets
6. Streamlit : les dépendances d’une application sur Community Cloud
7. NASA : les API ouvertes
8. Palmer penguins : les données
9. pethost, la ligne de commande de Pethost