Streamlit Cloud : déployer son app Python en 10 min (2026)

Streamlit Community Cloud est gratuit pour 1 app publique. Prérequis : compte GitHub + fichier requirements.txt. Durée : 8 à 15 minutes selon votre stack.

Vous avez créé votre première application Streamlit et vous voulez la partager avec le monde ? Ce guide couvre chaque étape du déploiement, y compris les 3 erreurs qui bloquent la majorité des développeurs lors du premier déploiement.

Ce que vous allez apprendre

✅ Déployer votre app Streamlit en 1 clic (gratuit)
✅ Configurer un domaine personnalisé (optionnel)
✅ Gérer les variables d'environnement et secrets
✅ Optimiser les performances de déploiement
✅ Résoudre les erreurs courantes
✅ Redéployer automatiquement à chaque modification

Prérequis : Une application Streamlit fonctionnelle en local et un compte GitHub (gratuit).

Pourquoi Streamlit Cloud ?

Comparaison avec les alternatives

Critère	Streamlit Cloud	Heroku	Render	Railway
Prix	✅ Gratuit illimité	❌ Payant (7$/mois)	⚠️ Gratuit limité	⚠️ Gratuit limité
Setup	⭐⭐⭐⭐⭐ 1 clic	⭐⭐⭐ Configuration	⭐⭐⭐ Configuration	⭐⭐⭐ Configuration
HTTPS	✅ Automatique	✅ Automatique	✅ Automatique	✅ Automatique
Redéploiement auto	✅ À chaque commit	⚠️ Manuel	✅ Configurable	✅ Configurable
Logs	✅ En temps réel	✅ Oui	✅ Oui	✅ Oui
Domaine custom	✅ Gratuit	❌ Payant	⚠️ Limité	⚠️ Limité

Verdict : Streamlit Cloud est imbattable pour héberger gratuitement des apps Streamlit.

Étape 0 : Préparer votre application

Avant de déployer, assurez-vous que votre projet a cette structure :

mon-app-streamlit/
├── app.py                 # Votre application principale
├── requirements.txt       # Dépendances Python
├── packages.txt           # Dépendances système (libssl, libgomp, ffmpeg...)
├── .streamlit/
│   └── config.toml       # Configuration (optionnel)
├── data/                  # Vos données (optionnel)
└── README.md             # Documentation

Créer le fichier requirements.txt

C'est crucial : listez toutes vos dépendances Python.

# Générer automatiquement
pip freeze > requirements.txt

Exemple de requirements.txt minimal :

streamlit==1.30.0
pandas==2.1.4
plotly==5.18.0

⚠️ Erreur courante : Oublier une dépendance = app qui crash au déploiement.

Le fichier packages.txt (souvent oublié, source de bugs silencieux)

requirements.txt liste les paquets Python. packages.txt liste les dépendances système — bibliothèques C/C++ nécessaires à certains paquets Python.

# packages.txt — dépendances système Ubuntu/Debian
libgomp1        # requis par LightGBM, XGBoost
libssl-dev      # requis par certains clients HTTP
ffmpeg          # requis par moviepy, pydub
libgeos-dev     # requis par shapely, geopandas

Quand en avez-vous besoin ? Si votre requirements.txt contient lightgbm, xgboost, shapely, geopandas, moviepy, ou tout paquet compilé avec des extensions C. Sans ce fichier, le déploiement réussit mais l'app plante à l'import — sans message d'erreur clair.

# Créez le fichier à la racine du projet
echo "libgomp1" > packages.txt
git add packages.txt
git commit -m "Add system dependencies"

Configuration optionnelle (.streamlit/config.toml)

Créez un fichier .streamlit/config.toml pour personnaliser l'apparence :

[theme]
primaryColor = "#FF4B4B"
backgroundColor = "#FFFFFF"
secondaryBackgroundColor = "#F0F2F6"
textColor = "#262730"
font = "sans serif"

[server]
headless = true
port = 8501

Étape 1 : Pousser votre code sur GitHub

Streamlit Cloud se connecte directement à GitHub pour déployer votre app.

Si vous n'avez pas encore de repo GitHub

# Dans le dossier de votre projet
git init
git add .
git commit -m "Initial commit - Mon app Streamlit"

# Créer un repo sur GitHub.com (via l'interface)
# Puis lier le repo local au remote
git remote add origin https://github.com/votre-username/mon-app-streamlit.git
git branch -M main
git push -u origin main

Si vous avez déjà un repo

git add .
git commit -m "Prêt pour déploiement Streamlit Cloud"
git push

✅ Checkpoint : Votre code est maintenant sur GitHub. Passons au déploiement !

Étape 2 : Créer un compte Streamlit Cloud

Allez sur share.streamlit.io
Cliquez sur "Sign up"
Connectez-vous avec votre compte GitHub (recommandé)

Pourquoi utiliser GitHub ? : Connexion directe à vos repos = déploiement en 1 clic.

Étape 3 : Déployer votre app en 1 clic

Via l'interface Streamlit Cloud

Cliquez sur "New app"
Sélectionnez votre repository GitHub
Choisissez la branche (généralement main)
Indiquez le chemin vers votre fichier principal : app.py
Cliquez sur "Deploy!"

Configuration avancée (optionnelle)

Avant de cliquer "Deploy", vous pouvez :

Changer l'URL de l'app :

Par défaut : https://votre-username-mon-app-streamlit.streamlit.app
Personnalisée : https://mon-app-custom.streamlit.app (gratuit !)

Choisir la version Python :

Python 3.9, 3.10, 3.11 disponibles
Recommandé : 3.10 (bon équilibre stabilité/nouveautés)

Étape 4 : Gérer les secrets et variables d'environnement

Si votre app utilise des API keys ou mots de passe, ne les committez JAMAIS dans GitHub !

Ajouter des secrets dans Streamlit Cloud

Ouvrez votre app sur Streamlit Cloud
Cliquez sur "Settings" (icône ⚙️)
Allez dans "Secrets"
Ajoutez vos secrets au format TOML :

# Secrets (format TOML)
OPENAI_API_KEY = "sk-..."
DATABASE_URL = "postgresql://user:pass@host:5432/db"

[api]
key = "ma-cle-secrete"
endpoint = "https://api.exemple.com"

Utiliser les secrets dans votre code

import streamlit as st

# Accéder aux secrets
api_key = st.secrets["OPENAI_API_KEY"]
db_url = st.secrets["DATABASE_URL"]

# Secrets imbriqués
api_endpoint = st.secrets["api"]["endpoint"]

⚠️ Sécurité : Les secrets sont chiffrés et jamais exposés dans les logs.

Alternative : Fichier .streamlit/secrets.toml (local uniquement)

Pour tester en local sans exposer vos secrets :

# .streamlit/secrets.toml (AJOUTER À .gitignore !)
OPENAI_API_KEY = "sk-test-local"

Important : Ajoutez ce fichier au .gitignore :

echo ".streamlit/secrets.toml" >> .gitignore
git add .gitignore
git commit -m "Ignore secrets file"

Étape 5 : Suivre le déploiement et déboguer

Logs en temps réel

Pendant le déploiement, Streamlit Cloud affiche les logs en temps réel :

[timestamp] Cloning repository...
[timestamp] Installing requirements from requirements.txt...
[timestamp] Collecting streamlit==1.30.0
[timestamp] Successfully installed streamlit-1.30.0
[timestamp] Starting app...
[timestamp] You can now view your Streamlit app in your browser.

Erreurs courantes et solutions

❌ Erreur : "No module named 'xxx'"

Cause : Dépendance manquante dans requirements.txt

Solution :

# En local, identifier la dépendance manquante
pip install xxx

# Ajouter à requirements.txt
echo "xxx==1.2.3" >> requirements.txt

# Commit et push
git add requirements.txt
git commit -m "Add missing dependency"
git push

Le redéploiement se fera automatiquement !

❌ Erreur : "Port 8501 is already in use"

Cause : Tentative de spécifier un port manuellement

Solution : Supprimez toute ligne st.set_option('server.port', ...) de votre code. Streamlit Cloud gère le port automatiquement.

❌ Erreur : "Memory limit exceeded"

Cause : Votre app utilise trop de RAM (limite : 1 GB sur plan gratuit)

Solutions :

Optimiser le chargement des données avec @st.cache_data
Réduire la taille des datasets
Passer à Streamlit Cloud Teams ($250/mois, 8 GB RAM)

import streamlit as st

@st.cache_data  # Cache les données pour économiser la RAM
def load_large_dataset():
    return pd.read_csv('huge_file.csv')

❌ Erreur : "File not found"

Cause : Chemin relatif incorrect

Solution : Utilisez des chemins relatifs depuis la racine du projet :

import os
import streamlit as st

# ❌ Mauvais
df = pd.read_csv('../data/file.csv')

# ✅ Bon
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
df = pd.read_csv(os.path.join(BASE_DIR, 'data', 'file.csv'))

# ✅ Encore mieux (Python 3.9+)
from pathlib import Path
df = pd.read_csv(Path(__file__).parent / 'data' / 'file.csv')

Étape 6 : Redéploiement automatique

La killer feature de Streamlit Cloud : le redéploiement automatique.

Comment ça marche ?

Vous modifiez votre code en local
Vous commitez et pushez sur GitHub
Streamlit Cloud détecte automatiquement le commit
Votre app se redéploie en 30-60 secondes

Exemple de workflow

# Modifier app.py
vim app.py

# Commiter et pousser
git add app.py
git commit -m "Fix: Corriger bug affichage graphique"
git push

# ✨ Streamlit Cloud redéploie automatiquement !
# Rafraîchir votre navigateur dans 30s pour voir les changements

Désactiver le redéploiement auto (optionnel)

Si vous voulez tester des changements sans redéployer :

Allez dans Settings > Auto-deploy
Désactivez "Automatically deploy when you push to main"
Cliquez manuellement sur "Reboot app" quand vous êtes prêt

Étape 7 : Configurer un domaine personnalisé (gratuit)

Par défaut, votre app est accessible sur :

https://votre-username-mon-app.streamlit.app

Vous pouvez configurer un domaine personnalisé gratuitement !

Option 1 : Sous-domaine Streamlit Cloud (gratuit, instant)

Lors du déploiement, choisissez un nom court :

https://ma-super-app.streamlit.app

Avantages :

✅ Gratuit
✅ HTTPS automatique
✅ Disponible instantanément

Option 2 : Votre propre domaine (nécessite un domaine)

Si vous possédez mondomaine.com, vous pouvez configurer :

https://app.mondomaine.com

Configuration DNS :

Ajoutez un enregistrement CNAME :
- Host : app
- Points to : votre-app.streamlit.app
- TTL : 3600
Dans Streamlit Cloud Settings :
- Custom domain : app.mondomaine.com

Délai : Propagation DNS 1-48h (généralement < 1h)

Étape 8 : Optimiser les performances

Cache intelligent avec @st.cache_data

import streamlit as st
import pandas as pd

@st.cache_data(ttl=3600)  # Cache 1h
def load_data():
    """Charge les données (coûteux)"""
    return pd.read_csv('https://exemple.com/big_data.csv')

# Utilisation
df = load_data()  # Premier appel : chargement
df = load_data()  # Appels suivants : instantané (cache)

Cache des connexions avec @st.cache_resource

import streamlit as st
from sqlalchemy import create_engine

@st.cache_resource
def init_db_connection():
    """Initialise la connexion DB (1 seule fois)"""
    return create_engine(st.secrets["DATABASE_URL"])

# Utilisation
engine = init_db_connection()
df = pd.read_sql("SELECT * FROM users", engine)

Lazy loading des données

import streamlit as st

# ❌ Mauvais : charge tout au démarrage
df = pd.read_csv('huge_file.csv')
st.dataframe(df)

# ✅ Bon : charge seulement ce qui est nécessaire
@st.cache_data
def load_filtered_data(category):
    df = pd.read_csv('huge_file.csv')
    return df[df['category'] == category]

category = st.selectbox("Catégorie", ["A", "B", "C"])
df = load_filtered_data(category)  # Charge uniquement la catégorie sélectionnée
st.dataframe(df)

Étape 9 : Monitoring et analytics

Logs de l'application

Accédez aux logs en temps réel :

Ouvrez votre app sur Streamlit Cloud
Cliquez sur "Manage app" (icône ⚙️)
Consultez les logs dans "Logs"

Métriques disponibles

Streamlit Cloud vous donne accès à :

Nombre de visiteurs uniques
Durée des sessions
Pages vues
Erreurs (crashes, timeouts)

Ajouter Google Analytics (optionnel)

import streamlit as st

# Injecter le script Google Analytics
st.markdown("""
<script async src="https://www.googletagmanager.com/gtag/js?id=G-XXXXXXXXXX"></script>
<script>
  window.dataLayer = window.dataLayer || [];
  function gtag(){dataLayer.push(arguments);}
  gtag('js', new Date());
  gtag('config', 'G-XXXXXXXXXX');
</script>
""", unsafe_allow_html=True)

Étape 10 : Limites du plan gratuit et alternatives

Limites Streamlit Cloud (plan gratuit)

Ressource	Limite gratuite	Impact
Apps publiques	Illimité	✅ Parfait pour side projects
Apps privées	1 seule	⚠️ Limité pour projets internes
RAM	1 GB	⚠️ Suffisant pour 80% des apps
CPU	Partagé	⚠️ Possible lenteur aux heures de pointe
Visiteurs	Illimité	✅ Excellent
Bande passante	Illimité	✅ Excellent

Quand upgrader vers Streamlit Cloud Teams ?

Passez à Teams ($250/mois) si :

✅ Vous avez besoin de plusieurs apps privées
✅ Votre app utilise > 1 GB de RAM
✅ Vous voulez un support prioritaire
✅ Vous avez besoin d'authentification SSO

Alternatives gratuites si limitations

Render.com (gratuit avec limites) :

# render.yaml
services:
  - type: web
    name: streamlit-app
    env: python
    buildCommand: pip install -r requirements.txt
    startCommand: streamlit run app.py --server.port=$PORT --server.address=0.0.0.0

Railway.app (5$/mois après trial) : Déploiement similaire à Streamlit Cloud

Docker + VPS (à partir de 5$/mois) : Contrôle total mais configuration manuelle

Checklist finale : Votre app est prête ?

Avant de partager votre app publiquement, vérifiez :

✅ Aucun secret n'est commité dans GitHub
✅ requirements.txt est à jour et complet
✅ L'app fonctionne en local sans erreur
✅ Les chemins de fichiers sont relatifs (pas absolus)
✅ Un README.md explique le projet
✅ Le cache est configuré pour les opérations coûteuses
✅ L'app a été testée sur plusieurs navigateurs
✅ Les données sensibles sont dans les secrets Streamlit
✅ Le design est responsive (mobile friendly)
✅ Les erreurs sont gérées avec try/except

Exemple complet : App météo déployée

Voici une mini-app complète prête à déployer :

Structure du projet

meteo-app/
├── app.py
├── requirements.txt
├── .streamlit/
│   └── config.toml
└── README.md

app.py

import streamlit as st
import requests
from datetime import datetime

st.set_page_config(page_title="Météo France", page_icon="🌤️")

st.title("🌤️ Météo en temps réel")

# Sélection de la ville
ville = st.selectbox(
    "Choisissez une ville",
    ["Paris", "Lyon", "Marseille", "Toulouse", "Nice"]
)

# API OpenWeather (nécessite une clé gratuite)
@st.cache_data(ttl=600)  # Cache 10 minutes
def get_weather(city):
    api_key = st.secrets["OPENWEATHER_API_KEY"]
    url = f"https://api.openweathermap.org/data/2.5/weather?q={city},fr&appid={api_key}&units=metric&lang=fr"
    return requests.get(url).json()

if st.button("Obtenir la météo"):
    with st.spinner("Chargement..."):
        data = get_weather(ville)

        if data.get("cod") == 200:
            temp = data["main"]["temp"]
            description = data["weather"][0]["description"]
            humidity = data["main"]["humidity"]

            col1, col2, col3 = st.columns(3)
            col1.metric("Température", f"{temp}°C")
            col2.metric("Humidité", f"{humidity}%")
            col3.metric("Conditions", description.capitalize())
        else:
            st.error("Impossible de récupérer les données météo")

st.caption(f"Dernière mise à jour : {datetime.now().strftime('%H:%M')}")

requirements.txt

streamlit==1.30.0
requests==2.31.0

Secrets (dans Streamlit Cloud)

OPENWEATHER_API_KEY = "votre-cle-api-gratuite"

Déploiement

git init
git add .
git commit -m "App météo Streamlit"
git remote add origin https://github.com/username/meteo-app.git
git push -u origin main

Puis déployez sur share.streamlit.io en 1 clic !

Les 3 raisons pour lesquelles votre déploiement échoue silencieusement

Ces 3 cas sont absents de la plupart des guides : l'app se déploie sans erreur, mais plante à l'utilisation — et les logs ne donnent pas d'indice clair.

1. Problème d'encodage UTF-8

Si vos données contiennent des caractères non-ASCII (accents, caractères spéciaux), un déploiement peut planter silencieusement lors de la lecture de fichiers CSV ou JSON.

Symptôme : l'app fonctionne en local (votre OS est configuré en UTF-8) mais plante sur Streamlit Cloud avec une UnicodeDecodeError ou charge des données corrompues.

# ❌ Problème : encoding implicite (dépend de l'OS)
df = pd.read_csv('données.csv')

# ✅ Solution : toujours spécifier l'encoding explicitement
df = pd.read_csv('données.csv', encoding='utf-8')

# Si votre fichier a été créé sous Windows (Excel)
df = pd.read_csv('données.csv', encoding='utf-8-sig')

Même chose pour les fichiers Python qui lisent du texte :

# ✅ Toujours spécifier l'encoding dans open()
with open('fichier.txt', 'r', encoding='utf-8') as f:
    contenu = f.read()

2. Secrets mal configurés (l'erreur la plus fréquente)

L'app se déploie, la page s'affiche, mais plante dès qu'un utilisateur déclenche une action qui accède à un secret.

La différence critique : st.secrets vs variables d'environnement

Méthode	Contexte local	Contexte Streamlit Cloud	Recommandé
`st.secrets["CLE"]`	`.streamlit/secrets.toml`	Interface Secrets Streamlit	✅ Oui
`os.environ["CLE"]`	Variables d'env locale	Non géré automatiquement	⚠️ Éviter
`os.getenv("CLE")`	Variables d'env locale	Non géré automatiquement	⚠️ Éviter

La règle : sur Streamlit Cloud, utilisez toujours st.secrets, jamais os.environ directement. Les variables d'environnement système ne sont pas injectées automatiquement depuis l'interface Secrets.

# ❌ Ne fonctionne pas sur Streamlit Cloud
import os
api_key = os.environ["OPENAI_API_KEY"]  # KeyError silencieux

# ✅ Fonctionne partout
import streamlit as st
api_key = st.secrets["OPENAI_API_KEY"]

Vérification avant déploiement : dans .streamlit/secrets.toml (fichier local uniquement, en .gitignore), listez exactement les mêmes clés que dans l'interface Secrets de Streamlit Cloud.

3. Dépendances système manquantes (`packages.txt` absent)

Décrit dans la section "Étape 0" ci-dessus. Symptôme typique : ImportError: libgomp.so.1: cannot open shared object file — l'erreur n'apparaît qu'à l'exécution, pas lors du build.

Commande de diagnostic : si vous ne savez pas quelles dépendances système sont nécessaires, vérifiez la doc du paquet ou cherchez [nom-paquet] linux system dependencies.

Résolution de problèmes avancés

Mon app est lente

Diagnostics :

Vérifiez l'utilisation de @st.cache_data sur les fonctions coûteuses
Profilez votre code avec streamlit run app.py --logger.level=debug
Réduisez la fréquence de st.rerun()

Solutions :

# ❌ Lent : rechargement à chaque interaction
df = pd.read_csv('big_file.csv')

# ✅ Rapide : cache
@st.cache_data
def load_data():
    return pd.read_csv('big_file.csv')

L'app se met en veille (sleep mode)

Comportement : Streamlit Community Cloud met votre app en veille après 15 minutes d'inactivité (aucun visiteur actif). La prochaine visite affiche un écran "This app has gone to sleep" avec un bouton "Wake up".

Temps de réveil (cold start) : 30 à 60 secondes selon la complexité des imports.

Minimiser l'impact du cold start avec @st.cache_resource :

La distinction entre st.cache_data et st.cache_resource est cruciale pour les cold starts :

import streamlit as st

# @st.cache_data — pour les données (sérialisables, copiées à chaque appel)
# Recréé à chaque réveil de l'app
@st.cache_data(ttl=3600)
def load_dataset():
    return pd.read_csv('data.csv')

# @st.cache_resource — pour les connexions et modèles (non sérialisables, partagés)
# Survit aux reruns MAIS est recréé au cold start
@st.cache_resource
def load_ml_model():
    import pickle
    with open('model.pkl', 'rb') as f:
        return pickle.load(f)

# Résultat : après un cold start de 45s, les interactions suivantes
# sont instantanées — le modèle est en mémoire jusqu'au prochain sleep
model = load_ml_model()

Règle de décision :

@st.cache_data : DataFrames, JSON, résultats d'API — données qui peuvent être copiées
@st.cache_resource : connexions DB, modèles ML, clients API — objets qui doivent être partagés et non dupliqués

Solution : Pour les apps critiques qui ne doivent pas dormir, passez au plan Teams ($250/mois) ou utilisez un cron job externe pour "pinger" l'app toutes les 10 minutes.

Erreur CORS avec une API externe

Solution : Utilisez un backend intermédiaire ou activez CORS sur votre API

# Si vous contrôlez l'API
from flask import Flask
from flask_cors import CORS

app = Flask(__name__)
CORS(app)  # Autoriser tous les domaines

Alternative méconnue : GitHub Actions + Streamlit CLI (pour le contrôle total)

Streamlit Cloud est parfait pour 80% des cas. Mais si vous avez besoin de contrôle total sur le déploiement (secrets complexes, étapes de build personnalisées, intégration continue avancée), voici une alternative puissante : déployer Streamlit via GitHub Actions vers un VPS.

# .github/workflows/deploy.yml
name: Deploy Streamlit App

on:
  push:
    branches: [main]

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

      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.11'

      - name: Install dependencies
        run: |
          pip install -r requirements.txt

      - name: Deploy via SSH
        uses: appleboy/ssh-action@v0.1.10
        with:
          host: ${{ secrets.SERVER_HOST }}
          username: ${{ secrets.SERVER_USER }}
          key: ${{ secrets.SSH_PRIVATE_KEY }}
          script: |
            cd /opt/streamlit-app
            git pull origin main
            pip install -r requirements.txt
            systemctl restart streamlit-app

Quand choisir cette approche :

Critère	Streamlit Cloud	GitHub Actions + VPS
Setup initial	5 min	30–60 min
Coût mensuel	Gratuit	5–10€/mois (VPS)
Contrôle du process	Limité	Total
Secrets complexes	Simple	Flexible
Uptime garanti	Non (sleep 15 min)	Oui (toujours actif)
RAM disponible	1 Go	Selon VPS (2–8 Go)

Commande Streamlit CLI pour serveur :

# Lancer en production avec nohup (reste actif après déconnexion SSH)
nohup streamlit run app.py \
  --server.port=8501 \
  --server.address=0.0.0.0 \
  --server.headless=true \
  > streamlit.log 2>&1 &

Cette approche est couverte en détail dans la formation Streamlit Unleashed (module déploiement : Docker, Railway, VPS, CI/CD).

Conclusion : Votre app Streamlit est en ligne !

Félicitations ! Vous savez maintenant :

✅ Déployer une app Streamlit gratuitement en 10 minutes ✅ Gérer les secrets et variables d'environnement ✅ Optimiser les performances avec le cache ✅ Résoudre les erreurs courantes ✅ Configurer un domaine personnalisé ✅ Monitorer votre application

Prochaines étapes :

Partagez votre app sur LinkedIn, Twitter, Reddit
Ajoutez votre app à la Streamlit Gallery
Collectez les feedbacks utilisateurs
Itérez et améliorez votre app

Ressources pour aller plus loin

Apprendre Streamlit

📚 Ma formation Streamlit Unleashed - Maîtrisez Streamlit en 20h
📄 Cheatsheet Streamlit gratuite - Tous les composants en 1 page
🔍 Audit gratuit de votre app - Analyse personnalisée en 2 min

Documentation officielle

Communauté

Besoin d'aide pour déployer votre app ? Testez gratuitement mon outil Roast My Streamlit - il analyse votre code et vous donne des recommandations personnalisées pour l'optimiser avant le déploiement !

Vous voulez créer des apps Streamlit professionnelles ? Découvrez ma formation Streamlit Unleashed : CSS avancé, authentification, déploiement multi-plateforme et 15 projets concrets.