Déployer un Dashboard Streamlit en Production : Le Guide Complet 2025 (Cloud, Docker, AWS)

Vous avez développé un magnifique dashboard Streamlit en local. Les graphiques s'affichent parfaitement, l'interface est fluide, vos collègues sont impressionnés par la démo sur votre machine.

Et puis vient LA question :

"Super ! Tu peux le mettre en ligne pour qu'on y accède depuis nos bureaux ?"

Soudain, vous réalisez que vous n'avez jamais déployé d'application Python en production. Docker, NGINX, AWS EC2... ces termes vous donnent des sueurs froides.

La bonne nouvelle : Déployer une application Streamlit en 2025 est devenu ridiculement simple. Vous pouvez avoir votre dashboard en ligne en 2 minutes chrono sans toucher à une ligne de configuration.

La vraie question : Quelle plateforme choisir selon vos besoins ?

Aujourd'hui, je vais vous montrer 5 façons de déployer Streamlit, du plus simple (gratuit, 2 minutes) au plus robuste (infrastructure enterprise avec CI/CD).

Le Problème du Développement Local

Votre application Streamlit tourne parfaitement sur votre laptop :

streamlit run app.py
# ✨ You can now view your app in your browser.
# Local URL: http://localhost:8501

Mais localhost:8501 n'est accessible que depuis votre machine. Pour qu'un collègue, client ou utilisateur puisse y accéder, vous devez :

1. Héberger votre code sur un serveur accessible 24/7
2. Exposer l'application avec une URL publique (HTTPS obligatoire en production)
3. Gérer les dépendances (versions Python, librairies, variables d'environnement)
4. Assurer la disponibilité (redémarrage automatique en cas de crash)
5. Monitorer les performances (logs, métriques, alertes)

C'est exactement ce que font les plateformes de déploiement. Mais toutes ne se valent pas selon vos besoins.

Vue d'Ensemble : 5 Options de Déploiement

Avant de plonger dans les tutoriels détaillés, voici le panorama complet :

Plateforme	Temps Déploiement	Coût Départ	Scalabilité	Complexité	Cas d'Usage
Streamlit Cloud	2 minutes	Gratuit	Limitée	⭐ Très simple	Prototypes, démos, POC
Render	5 minutes	Gratuit puis $7/mois	Moyenne	⭐⭐ Simple	Apps moyennes, startups
Railway	3 minutes	$5/mois (500h)	Moyenne	⭐⭐ Simple	Développeurs, side-projects
Docker + VPS	30 minutes	$5-20/mois	Haute	⭐⭐⭐⭐ Complexe	Apps custom, contrôle total
AWS EC2	1 heure	$10-50/mois	Très haute	⭐⭐⭐⭐⭐ Expert	Enterprise, haute disponibilité

Règle d'or : Commencez par Streamlit Cloud pour valider votre concept. Migrez vers une solution plus robuste quand vous avez des utilisateurs réels.

Pourquoi ? Parce que 95% des projets Streamlit n'ont pas besoin d'AWS. Ne sur-optimisez pas prématurément.

Option 1 : Streamlit Cloud (Le Plus Simple)

Pour qui : Démos, prototypes, applications internes légères Temps : 2 minutes Coût : Gratuit (plan Community) ou $20/mois/app (plan Standard)

Pourquoi C'est La Meilleure Option Pour Débuter

Streamlit Cloud est créé par l'équipe Streamlit chez Snowflake. C'est la solution la plus intégrée :

• ✅ Zéro configuration : Pas de Dockerfile, pas de requirements complexes
• ✅ Déploiement Git : Push sur GitHub → app déployée automatiquement
• ✅ HTTPS gratuit : Certificat SSL géré automatiquement
• ✅ Secrets management : Interface GUI pour les variables d'environnement
• ✅ Logs en temps réel : Debugging directement dans l'interface

Limitation principale : 1GB de RAM sur le plan gratuit. Si votre app charge des datasets de plusieurs GB, vous allez avoir des problèmes.

Déploiement Pas à Pas

Étape 1 : Préparez votre dépôt GitHub

Votre projet doit avoir cette structure minimale :

mon-dashboard/
├── app.py                    # Votre application principale
├── requirements.txt          # Dépendances Python
└── .streamlit/
    └── config.toml          # (Optionnel) Configuration Streamlit

Fichier requirements.txt :

streamlit==1.40.0
pandas==2.2.0
plotly==5.18.0
requests==2.31.0

Important : Spécifiez les versions exactes pour éviter les surprises.

Étape 2 : Poussez votre code sur GitHub

git init
git add .
git commit -m "Initial commit"
git remote add origin https://github.com/votre-username/mon-dashboard.git
git push -u origin main

Étape 3 : Connectez-vous à Streamlit Cloud

1. Allez sur share.streamlit.io
2. Connectez votre compte GitHub
3. Cliquez sur "New app"
4. Sélectionnez votre dépôt, branche (main) et fichier (app.py)
5. Cliquez sur "Deploy!"

C'est tout. En 30 secondes, votre app est en ligne avec une URL du type https://votre-app-unique.streamlit.app.

Gestion des Secrets (Variables d'Environnement)

Si votre app utilise des API keys, mots de passe ou tokens :

# app.py
import streamlit as st

# ❌ JAMAIS EN DUR DANS LE CODE
# api_key = "sk-proj-abc123..."

# ✅ Utilisez st.secrets
api_key = st.secrets["OPENAI_API_KEY"]

Dans l'interface Streamlit Cloud :

1. Allez dans "App settings" → "Secrets"
2. Ajoutez vos secrets au format TOML :

# Format TOML (comme config.toml)
OPENAI_API_KEY = "sk-proj-abc123..."
DATABASE_URL = "postgresql://user:pass@host/db"

[api_credentials]
username = "admin"
password = "secure_password"

Ces secrets sont chiffrés et jamais exposés dans les logs.

Redéploiement Automatique

Chaque git push sur votre branche principale déclenche un redéploiement automatique. Vous pouvez aussi :

• Redéployer manuellement depuis l'interface
• Désactiver le redéploiement automatique pour contrôler les mises en production

Limitations du Plan Gratuit

Le plan Community (gratuit) a ces contraintes :

• 1 GB de RAM par app
• 1 CPU partagé (performance variable)
• Veille après 7 jours d'inactivité (réveil automatique au premier accès)
• Repos publics uniquement (code source visible sur GitHub)

Pour lever ces limites, le plan Standard ($20/mois/app) offre :

• 4 GB de RAM et 2 CPUs dédiés
• Toujours actif (pas de veille)
• Repos privés supportés

Option 2 : Render (Le Meilleur Rapport Facilité/Prix)

Pour qui : Applications avec trafic régulier, startups, MVPs Temps : 5 minutes Coût : Gratuit (avec limitations) ou $7/mois

Pourquoi Render Est Une Alternative Solide

Render est une plateforme PaaS (Platform as a Service) moderne qui fait beaucoup plus que Streamlit Cloud :

• ✅ Multi-services : Déployez aussi des bases de données, workers, cron jobs
• ✅ Pas de veille sur le plan payant ($7/mois)
• ✅ Scalabilité automatique : Ajustez RAM et CPU en un clic
• ✅ Domaines custom : dashboard.votre-entreprise.com
• ✅ Healthchecks automatiques : Redémarre l'app si elle crash

Quand choisir Render plutôt que Streamlit Cloud :

• Vous avez besoin de plus de 1GB de RAM
• Vous voulez éviter la mise en veille (plan gratuit Render = veille après 15min, mais réveil en <30s)
• Vous déployez plusieurs services (app Streamlit + API FastAPI + PostgreSQL)

Déploiement Pas à Pas

Étape 1 : Créez un compte sur render.com

Connectez votre compte GitHub pour accéder à vos dépôts.

Étape 2 : Créez un nouveau Web Service

1. Cliquez sur "New +" → "Web Service"
2. Sélectionnez votre dépôt GitHub
3. Configurez les paramètres :

Name: mon-dashboard-streamlit
Region: Frankfurt (Europe) ou Oregon (USA)
Branch: main
Runtime: Python 3
Build Command: pip install -r requirements.txt
Start Command: streamlit run app.py --server.port=$PORT --server.address=0.0.0.0

Important : Le --server.port=$PORT est obligatoire. Render assigne dynamiquement un port, et Streamlit doit l'écouter.

Étape 3 : Variables d'environnement

Dans l'onglet "Environment", ajoutez vos secrets :

OPENAI_API_KEY = sk-proj-abc123...
DATABASE_URL = postgresql://...

Contrairement à Streamlit Cloud qui utilise st.secrets, sur Render vous utilisez os.environ :

import os
import streamlit as st

api_key = os.environ.get("OPENAI_API_KEY")

# Alternative : Utilisez python-dotenv pour le développement local
from dotenv import load_dotenv
load_dotenv()  # Charge .env en local, ignoré en production

Étape 4 : Déployez

Cliquez sur "Create Web Service". Render va :

1. Cloner votre dépôt
2. Installer les dépendances (pip install -r requirements.txt)
3. Lancer votre app (streamlit run app.py...)
4. Exposer votre app sur https://mon-dashboard-streamlit.onrender.com

Le premier déploiement prend 2-3 minutes.

Plan Gratuit vs Payant

Plan Free ($0/mois) :

• ✅ 512 MB de RAM
• ✅ CPU partagé
• ❌ Veille après 15 minutes d'inactivité
• ❌ Réveil lent (30-60 secondes)

Plan Starter ($7/mois) :

• ✅ 512 MB de RAM (suffisant pour la plupart des apps)
• ✅ CPU dédié
• ✅ Toujours actif (pas de veille)
• ✅ Réveil instantané

Pour 90% des dashboards internes, le plan Starter à $7/mois est largement suffisant.

Domaine Custom

Vous voulez dashboard.votre-entreprise.com au lieu de .onrender.com ?

1. Dans Render, allez dans "Settings" → "Custom Domain"
2. Ajoutez votre domaine
3. Configurez un enregistrement CNAME chez votre registrar :

dashboard.votre-entreprise.com → CNAME → mon-dashboard-streamlit.onrender.com

Render génère automatiquement un certificat SSL via Let's Encrypt. HTTPS gratuit.

Option 3 : Railway (L'Option Developer-Friendly)

Pour qui : Développeurs qui veulent un workflow Git moderne Temps : 3 minutes Coût : $5/mois pour 500h d'exécution

Pourquoi Railway Séduit Les Développeurs

Railway est la plateforme la plus developer-centric :

• ✅ Detection automatique : Pas besoin de spécifier "Python" ou "Streamlit", Railway devine
• ✅ Déploiement branch-based : Déployez automatiquement des previews par PR
• ✅ Interface CLI puissante : railway run python app.py pour tester en local avec les secrets de prod
• ✅ Logs en temps réel : Stream de logs dans le terminal ou l'interface web

Inconvénient : Pas de plan gratuit permanent. Vous payez à l'usage (500h pour $5/mois = ~20 jours d'uptime).

Déploiement Pas à Pas

Étape 1 : Créez un compte sur railway.app

Étape 2 : Installez la CLI Railway (optionnel mais recommandé)

npm install -g @railway/cli
# Ou avec Homebrew sur macOS
brew install railway

Étape 3 : Initialisez votre projet

cd mon-dashboard
railway login
railway init

Railway va détecter automatiquement que c'est une app Python Streamlit.

Étape 4 : Configurez les variables

Si vous utilisez la CLI :

railway variables set OPENAI_API_KEY=sk-proj-abc123...

Ou depuis l'interface web : Variables → Add Variable.

Étape 5 : Déployez

railway up

Ou connectez votre dépôt GitHub depuis l'interface web pour des déploiements automatiques.

Votre app sera disponible sur https://[projet-id].up.railway.app.

Gestion des Environnements (Staging/Production)

Railway brille pour gérer plusieurs environnements :

# Créez un environnement staging
railway environment create staging

# Déployez sur staging
railway up --environment staging

# Passez en production
railway environment create production
railway up --environment production

Chaque environnement a ses propres variables, domaines et configurations.

Monitoring et Logs

Railway affiche en temps réel :

• Utilisation CPU/RAM : Graphiques avec historique
• Logs applicatifs : Filtres par service, niveau de log
• Coût estimé : Combien vous consommez ce mois-ci

Pour voir les logs en temps réel depuis le terminal :

railway logs --tail

Option 4 : Docker + VPS (Contrôle Total)

Pour qui : Apps avec besoins spécifiques, budgets serrés, apprentissage DevOps Temps : 30-60 minutes Coût : $5-20/mois (VPS chez DigitalOcean, Hetzner, OVH)

Pourquoi Docker + VPS ?

Les solutions PaaS (Streamlit Cloud, Render, Railway) sont pratiques mais limitées :

• Vous ne pouvez pas installer de logiciels système (ex: GDAL pour géospatial)
• Vous ne contrôlez pas la stack réseau (reverse proxy, rate limiting)
• Les coûts augmentent vite avec la RAM (AWS Lambda = $0.0000166667/GB-seconde, mais 10GB = $120/mois)

Avec Docker + VPS, vous avez :

• ✅ Contrôle total sur l'environnement
• ✅ Coûts prévisibles : $5/mois pour un VPS 1GB chez Hetzner
• ✅ Scalabilité manuelle : Ajoutez des serveurs, load balancers, etc.
• ❌ Complexité élevée : Vous gérez TOUT (sécurité, mises à jour, monitoring)

Quand choisir cette option :

• Vous avez des compétences DevOps (ou voulez les acquérir)
• Vous déployez plusieurs apps et voulez mutualiser les coûts
• Vous avez des contraintes de souveraineté (données en Europe, RGPD)

Architecture Cible

Voici ce que nous allons construire :

Internet
   ↓
NGINX Reverse Proxy (port 80/443)
   ↓
Docker Container Streamlit (port 8501)

NGINX gère :

• HTTPS : Certificat SSL via Certbot (Let's Encrypt)
• Compression : Gzip pour réduire la bande passante
• Cache : Headers cache pour les assets statiques

Déploiement Pas à Pas

Étape 1 : Louez un VPS

Chez Hetzner (excellent rapport qualité/prix) :

• CX11 : 2GB RAM, 1 vCPU, 20GB SSD → 3,79€/mois
• CX21 : 4GB RAM, 2 vCPU, 40GB SSD → 5,83€/mois

Choisissez Ubuntu 24.04 LTS comme OS.

Étape 2 : Connectez-vous en SSH

ssh root@votre-ip-vps

Étape 3 : Installez Docker

# Mise à jour système
apt update && apt upgrade -y

# Installation Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh

# Installation Docker Compose
apt install docker-compose -y

# Vérification
docker --version
docker-compose --version

Étape 4 : Créez votre Dockerfile

Sur votre machine locale, dans votre projet :

# Dockerfile
FROM python:3.11-slim

WORKDIR /app

# Copie des dépendances
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copie du code
COPY . .

# Exposition du port Streamlit
EXPOSE 8501

# Healthcheck pour monitoring
HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health || exit 1

# Commande de démarrage
CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

Étape 5 : Créez docker-compose.yml

# docker-compose.yml
version: '3.8'

services:
  streamlit:
    build: .
    container_name: streamlit-app
    ports:
      - "8501:8501"
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - DATABASE_URL=${DATABASE_URL}
    restart: unless-stopped
    volumes:
      - ./data:/app/data  # Persiste les données locales

Étape 6 : Déployez sur le VPS

# Sur votre machine locale, envoyez les fichiers
scp -r mon-dashboard root@votre-ip-vps:/root/

# Sur le VPS, lancez Docker Compose
ssh root@votre-ip-vps
cd /root/mon-dashboard
docker-compose up -d

# Vérifiez que ça tourne
docker ps
docker logs streamlit-app

Votre app est maintenant accessible sur http://votre-ip-vps:8501.

Étape 7 : Configurez NGINX + HTTPS

Installez NGINX :

apt install nginx certbot python3-certbot-nginx -y

Créez la configuration NGINX :

# /etc/nginx/sites-available/streamlit
server {
    listen 80;
    server_name dashboard.votre-domaine.com;

    location / {
        proxy_pass http://localhost:8501;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # Timeouts pour requêtes longues
        proxy_read_timeout 300s;
        proxy_connect_timeout 75s;
    }
}

Activez la configuration :

ln -s /etc/nginx/sites-available/streamlit /etc/nginx/sites-enabled/
nginx -t  # Teste la configuration
systemctl restart nginx

Obtenez un certificat SSL gratuit :

certbot --nginx -d dashboard.votre-domaine.com

Certbot va :

1. Modifier automatiquement la config NGINX pour écouter sur le port 443 (HTTPS)
2. Générer un certificat Let's Encrypt (valide 90 jours)
3. Configurer le renouvellement automatique

Votre app est maintenant accessible sur https://dashboard.votre-domaine.com ! 🎉

Mises à Jour et CI/CD

Pour mettre à jour l'app :

# Sur le VPS
cd /root/mon-dashboard
git pull origin main
docker-compose down
docker-compose up -d --build

Pour automatiser avec GitHub Actions, voir la section CI/CD plus bas.

Option 5 : AWS EC2 (Enterprise)

Pour qui : Applications enterprise avec haute disponibilité, scalabilité massive Temps : 1-2 heures Coût : $10-500+/mois selon la taille

Pourquoi AWS EC2 ?

AWS est le choix pour les applications critiques nécessitant :

• ✅ SLA 99.99% : Garantie de disponibilité contractuelle
• ✅ Auto-scaling : Ajoutez automatiquement des serveurs selon la charge
• ✅ Load balancing : Distribuer le trafic sur plusieurs instances
• ✅ Intégration AWS : RDS (base de données), S3 (stockage), CloudWatch (monitoring)

Inconvénients :

• ❌ Complexité extrême : IAM, VPC, Security Groups, subnets...
• ❌ Coûts variables : Facture surprise possible si mal configuré
• ❌ Courbe d'apprentissage : Documentation AWS volumineuse

Quand choisir AWS :

• Votre entreprise utilise déjà AWS (cohérence d'infrastructure)
• Vous avez plus de 10 000 utilisateurs actifs
• Vous devez respecter des SLA stricts (disponibilité 99.9%+)

Déploiement Simplifié avec Elastic Beanstalk

Au lieu de configurer manuellement EC2 + Load Balancer + Auto Scaling, utilisez Elastic Beanstalk (PaaS d'AWS) :

Étape 1 : Installez AWS CLI et EB CLI

pip install awsebcli
aws configure  # Entrez vos credentials AWS

Étape 2 : Initialisez Elastic Beanstalk

cd mon-dashboard
eb init -p python-3.11 streamlit-app --region eu-west-1

Étape 3 : Créez un fichier de configuration

# .ebextensions/streamlit.config
option_settings:
  aws:elasticbeanstalk:application:environment:
    STREAMLIT_SERVER_PORT: 8501
    STREAMLIT_SERVER_ADDRESS: 0.0.0.0
  aws:elasticbeanstalk:container:python:
    WSGIPath: app:app  # Non utilisé par Streamlit mais requis

Étape 4 : Créez un Procfile

web: streamlit run app.py --server.port=$PORT --server.address=0.0.0.0

Étape 5 : Déployez

eb create streamlit-env
eb open  # Ouvre l'app dans le navigateur

Elastic Beanstalk va automatiquement :

• Créer une instance EC2 (t3.micro par défaut)
• Configurer un Load Balancer
• Installer Python et vos dépendances
• Exposer votre app sur une URL .elasticbeanstalk.com

Coût estimé : ~$15-30/mois pour une petite instance avec Load Balancer.

Monitoring avec CloudWatch

AWS CloudWatch collecte automatiquement :

• Métriques système : CPU, RAM, réseau
• Logs applicatifs : Stderr/stdout de votre app
• Alarmes : Notifications si CPU > 80% pendant 5 minutes

Pour voir les logs :

eb logs

Pour configurer des alarmes :

aws cloudwatch put-metric-alarm \
  --alarm-name streamlit-high-cpu \
  --comparison-operator GreaterThanThreshold \
  --evaluation-periods 2 \
  --metric-name CPUUtilization \
  --namespace AWS/EC2 \
  --period 300 \
  --statistic Average \
  --threshold 80 \
  --actions-enabled \
  --alarm-actions arn:aws:sns:eu-west-1:123456789:admin-alerts

CI/CD avec GitHub Actions (Tous Les Déploiements)

Automatisez vos déploiements : chaque git push déclenche un redéploiement automatique.

Pour Render

Créez .github/workflows/deploy-render.yml :

name: Deploy to Render

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Trigger Render Deployment
        run: |
          curl -X POST ${{ secrets.RENDER_DEPLOY_HOOK_URL }}

Dans Render, copiez le "Deploy Hook" (Settings → Deploy Hook) et ajoutez-le comme secret RENDER_DEPLOY_HOOK_URL dans GitHub (Settings → Secrets).

Pour Docker + VPS

name: Deploy to VPS

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Deploy to VPS via SSH
        uses: appleboy/ssh-action@master
        with:
          host: ${{ secrets.VPS_HOST }}
          username: root
          key: ${{ secrets.VPS_SSH_KEY }}
          script: |
            cd /root/mon-dashboard
            git pull origin main
            docker-compose down
            docker-compose up -d --build

Ajoutez dans GitHub Secrets :

• VPS_HOST : Adresse IP de votre VPS
• VPS_SSH_KEY : Clé SSH privée (générée avec ssh-keygen)

Pour AWS Elastic Beanstalk

name: Deploy to AWS

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Generate deployment package
        run: zip -r deploy.zip . -x '*.git*'

      - name: Deploy to EB
        uses: einaregilsson/beanstalk-deploy@v21
        with:
          aws_access_key: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws_secret_key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          application_name: streamlit-app
          environment_name: streamlit-env
          version_label: ${{ github.sha }}
          region: eu-west-1
          deployment_package: deploy.zip

Benchmarks : Temps et Coûts de Déploiement

J'ai déployé la même application Streamlit (dashboard NYC Taxi, 2.4M lignes) sur les 5 plateformes. Voici les résultats :

Plateforme	Temps Initial	Temps Redéploiement	Coût Mensuel	Temps Chargement
Streamlit Cloud	2 min	30 sec	Gratuit	1.2s
Render (Free)	5 min	2 min	Gratuit	3.5s (réveil 45s)
Render (Starter)	5 min	2 min	$7	1.1s
Railway	3 min	1 min	$5 (500h)	0.9s
Docker + VPS	45 min	3 min	$5 (Hetzner)	0.7s
AWS EB	90 min	5 min	$25	0.8s

Observations :

• Streamlit Cloud : Inégalable pour la simplicité (2 min de bout en bout)
• Render Free : Réveil lent (45s) rédhibitoire pour apps publiques
• Railway : Meilleur compromis performance/prix pour side-projects
• Docker + VPS : Meilleure performance pour le prix, mais complexe
• AWS : Overkill pour 90% des cas (sauf si déjà dans l'écosystème AWS)

Matrice de Décision : Quelle Plateforme Pour Votre Cas ?

Utilisez ce tableau pour choisir :

Critère	Streamlit Cloud	Render	Railway	Docker + VPS	AWS
Temps de setup	⭐⭐⭐⭐⭐ 2min	⭐⭐⭐⭐ 5min	⭐⭐⭐⭐⭐ 3min	⭐⭐ 45min	⭐ 90min
Coût démarrage	Gratuit	Gratuit	$5	$5	$25
Scalabilité	⭐⭐ Limitée	⭐⭐⭐ Moyenne	⭐⭐⭐ Moyenne	⭐⭐⭐⭐ Haute	⭐⭐⭐⭐⭐ Très haute
Performance	⭐⭐⭐ Correcte	⭐⭐⭐ Correcte	⭐⭐⭐⭐ Bonne	⭐⭐⭐⭐ Bonne	⭐⭐⭐⭐⭐ Excellente
Contrôle	⭐ Minimal	⭐⭐ Faible	⭐⭐ Faible	⭐⭐⭐⭐⭐ Total	⭐⭐⭐⭐⭐ Total
Support	⭐⭐⭐⭐ Docs + Forum	⭐⭐⭐ Docs	⭐⭐⭐ Docs + Discord	⭐ Communauté	⭐⭐⭐⭐⭐ Premium

Recommandations par cas d'usage :

• Prototype/démo → Streamlit Cloud (gratuit, rapide)
• MVP startup → Render Starter ($7, toujours actif)
• Side-project perso → Railway ($5, interface dev-friendly)
• App interne entreprise → Docker + VPS (souveraineté, coûts maîtrisés)
• Produit SaaS > 10K users → AWS (scalabilité, SLA)

Les Erreurs Classiques à Éviter

Après avoir aidé 500+ étudiants à déployer leurs apps Streamlit, voici les pièges récurrents :

1. Oublier --server.address=0.0.0.0

# ❌ Mauvais (écoute uniquement localhost)
streamlit run app.py

# ✅ Bon (écoute toutes les interfaces réseau)
streamlit run app.py --server.address=0.0.0.0

Sans 0.0.0.0, votre app n'est pas accessible depuis l'extérieur du container/serveur.

2. Versions non-fixées dans requirements.txt

# ❌ Mauvais (version flottante = bugs futurs)
streamlit
pandas

# ✅ Bon (versions exactes = reproductibilité)
streamlit==1.40.0
pandas==2.2.0

Un jour, une mise à jour breaking change de Streamlit cassera votre app en production.

3. Secrets en dur dans le code

# ❌ JAMAIS ÇA
api_key = "sk-proj-abc123..."

# ✅ Variables d'environnement
import os
api_key = os.environ.get("OPENAI_API_KEY")

# ✅ Ou st.secrets sur Streamlit Cloud
import streamlit as st
api_key = st.secrets["OPENAI_API_KEY"]

Les secrets en dur finissent sur GitHub → scanners automatiques → compte piraté.

4. Charger des Datasets Géants Sans Cache

import streamlit as st
import pandas as pd

# ❌ Charge le CSV à CHAQUE interaction utilisateur
df = pd.read_csv("big_data.csv")

# ✅ Cache avec @st.cache_data
@st.cache_data
def load_data():
    return pd.read_csv("big_data.csv")

df = load_data()  # Chargé 1 seule fois, mis en cache

Sans cache, chaque clic sur un widget recharge le dataset = app ultra-lente.

5. Ignorer les Healthchecks

Render, Railway et AWS redémarrent automatiquement votre app si le healthcheck échoue. Configurez-le :

# app.py
import streamlit as st

# Streamlit expose automatiquement /_stcore/health
# Mais vous pouvez ajouter une logique custom :

if st.session_state.get("database_connected"):
    st.success("✅ App healthy")
else:
    st.error("❌ Database connection failed")
    # Loguez l'erreur, envoyez une alerte, etc.

FAQ : Questions Fréquentes

Puis-je déployer Streamlit gratuitement à vie ?

Oui, avec Streamlit Cloud (plan Community) :

• ✅ Gratuit à vie
• ✅ 1 app publique
• ❌ Limité à 1GB RAM
• ❌ Mise en veille après 7 jours d'inactivité

Pour des apps toujours actives, budget minimum : $5-7/mois (Railway ou Render).

Mon app est lente, comment l'optimiser ?

Checklist performance :

1. ✅ Utilisez @st.cache_data pour les chargements de données
2. ✅ Utilisez @st.cache_resource pour les connexions (DB, modèles ML)
3. ✅ Convertissez vos CSV en Parquet (5x plus rapide)
4. ✅ Limitez les rerun : st.fragment() pour isoler les parties interactives
5. ✅ Ajoutez plus de RAM/CPU sur votre plateforme

Lisez mon guide complet sur les 13 erreurs courantes Streamlit.

Comment gérer plusieurs apps Streamlit ?

Option 1 : Multi-pages Streamlit (1 dépôt)

mon-projet/
├── app.py              # Page d'accueil
├── pages/
│   ├── 1_Dashboard.py
│   ├── 2_Analytics.py
│   └── 3_Admin.py

Option 2 : Déploiements séparés (plusieurs dépôts)

Déployez chaque app sur son propre sous-domaine :

• dashboard.votre-domaine.com → App 1
• analytics.votre-domaine.com → App 2
• admin.votre-domaine.com → App 3

Puis-je utiliser une base de données avec Streamlit ?

Absolument. Streamlit fonctionne avec :

• ✅ PostgreSQL : Via psycopg2 ou SQLAlchemy
• ✅ MySQL : Via mysql-connector-python
• ✅ MongoDB : Via pymongo
• ✅ SQLite : Base locale (attention : non-persistante sur certaines plateformes)

Exemple avec PostgreSQL :

import streamlit as st
import psycopg2

@st.cache_resource
def get_db_connection():
    return psycopg2.connect(st.secrets["DATABASE_URL"])

conn = get_db_connection()
cursor = conn.cursor()
cursor.execute("SELECT * FROM users LIMIT 10")
data = cursor.fetchall()
st.dataframe(data)

Sur Render/Railway/AWS, ajoutez un service PostgreSQL (bases gérées disponibles).

Comment sécuriser mon dashboard Streamlit ?

Option 1 : Authentification native (Streamlit ≥ 1.42)

import streamlit as st

# Depuis Streamlit 1.42, login natif disponible
st.login(
    providers=["google", "github"],
    allowed_domains=["votre-entreprise.com"]
)

Option 2 : Librairie streamlit-authenticator

import streamlit_authenticator as stauth

authenticator = stauth.Authenticate(
    names=["Admin", "User"],
    usernames=["admin", "user"],
    passwords=["hashed_pw1", "hashed_pw2"],  # Utilisez bcrypt
    cookie_name="my_app",
    key="random_signature_key",
    cookie_expiry_days=30
)

name, authentication_status, username = authenticator.login("Login", "main")

if authentication_status:
    st.write(f"Bienvenue {name}")
elif authentication_status == False:
    st.error("Username/password incorrect")

Lisez mon guide complet sur l'authentification Streamlit.

Quelle est la différence entre PaaS et VPS ?

PaaS (Platform as a Service) : Streamlit Cloud, Render, Railway, AWS Elastic Beanstalk

• ✅ Abstraction maximale (pas de gestion serveur)
• ✅ Déploiement Git automatique
• ❌ Coûts plus élevés à grande échelle
• ❌ Moins de contrôle

VPS (Virtual Private Server) : DigitalOcean, Hetzner, OVH

• ✅ Contrôle total (root access)
• ✅ Coûts prévisibles ($5-20/mois)
• ❌ Vous gérez TOUT (sécurité, mises à jour, monitoring)
• ❌ Courbe d'apprentissage Linux/Docker

Règle : Commencez PaaS, migrez VPS quand vous avez des besoins spécifiques ou des coûts trop élevés.

🚀 Maîtrisez Streamlit de A à Z

Déployer en production n'est qu'une étape du cycle de vie d'une application Streamlit. Pour créer des dashboards professionnels qui impressionnent vos clients et vos collègues, vous devez maîtriser :

Streamlit Unleashed : La Formation Complète

Dans ma formation Streamlit Unleashed, je vous apprends à créer des applications data modernes de bout en bout :

✅ Architecture Production-Ready

• Optimisation des performances (cache, fragments, lazy loading)
• Sécurité et authentification (streamlit-authenticator, OAuth)
• Gestion des secrets et variables d'environnement
• Monitoring et logging (intégration Sentry, Datadog)

✅ Déploiement Multi-Plateforme

• Streamlit Cloud : Configuration optimale (secrets, domaines custom)
• Docker : Création d'images optimisées (multi-stage builds)
• CI/CD : GitHub Actions pour déploiements automatisés
• AWS/Azure : Déploiement enterprise avec Terraform

✅ Intégrations Avancées

• Bases de données : PostgreSQL, MongoDB, Snowflake
• APIs externes : REST, GraphQL, webhooks
• DuckDB + Polars pour analyse de gros volumes
• Visualisations interactives : Plotly, Altair, Deck.gl

✅ Projets Concrets

• Dashboard analytics temps réel (10K+ lignes de données)
• App ML de prédiction avec FastAPI backend
• Système de monitoring avec alertes automatiques
• Portfolio de 5+ projets déployables immédiatement

Conclusion : Choisissez La Simplicité d'Abord

Vous savez maintenant comment déployer Streamlit sur 5 plateformes différentes, du plus simple (Streamlit Cloud, 2 minutes) au plus robuste (AWS, architecture enterprise).

Mon conseil : Ne sur-optimisez pas prématurément.

Commencez par Streamlit Cloud pour valider votre concept. Si vous dépassez 1GB de RAM ou avez besoin d'un domaine custom, passez à Render ($7/mois). Si vous développez un produit SaaS avec des milliers d'utilisateurs, alors seulement envisagez AWS.

La plupart des dashboards n'ont pas besoin d'auto-scaling, de load balancers et de 99.99% de disponibilité. Ils ont besoin d'être en ligne, rapides et fiables. Et pour ça, Streamlit Cloud ou Render font largement le job.

Rappelez-vous : Votre temps est précieux. Passer 8 heures à configurer Kubernetes pour une app qui a 10 utilisateurs, c'est du temps que vous ne passez pas à améliorer votre produit.

Déployez simple. Itérez vite. Optimisez quand c'est nécessaire.

---

Prêt à passer en production ?

👉 Découvrez Streamlit Unleashed et maîtrisez le déploiement de bout en bout avec des projets concrets.

Besoin d'aide pour déployer votre app ? Rejoignez notre communauté Discord où 500+ développeurs s'entraident quotidiennement.

Des questions sur le déploiement ? Contactez-moi sur LinkedIn où je partage mes retours d'expérience avec 25K+ professionnels data.

Envie d'aller plus loin ? Inscrivez-vous à DataGyver, ma newsletter mensuelle avec des tutoriels approfondis, benchmarks et case studies sur les technologies data modernes.