Migrer depuis Express

Il existe deux chemins pour migrer une application.js Express vers bext : remplacement complet (traduire les modèles Express en fonctionnalités natives bext) ou proxy inverse (conserver Express derrière bext ). Choisissez en fonction de la complexité de votre application.

Stratégie migratoire#

Approche	Idéal pour	Effort
Remplacement complet	Sites statiques, API REST, applications SSR avec middleware standard	Faible-moyen
Proxy inverse	Applications complexes Express avec chaînes de middleware approfondies et protocoles personnalisés	Faible
Hybride	Remplacez le service statique et TLS par bext, conservez Express pour les routes API	Faible

Traduction de middleware#

Service de fichiers statiques#

Express:

app.use(express.static('public'));
app.use('/assets', express.static('dist/assets'));

bext.config.toml :

toml

[server]
static_dir = "public"

[[route_rules]]
pattern = "/assets/**"
static_dir = "dist/assets"

bext sert des fichiers statiques avec compression automatique Brotli/gzip, en-têtes ETag et Cache-Control. Aucun middleware n'est nécessaire.

CORS#

Express:

const cors = require('cors');
app.use(cors({
  origin: ['https://app.example.com', 'https://admin.example.com'],
  credentials: true,
}));

bext.config.toml :

toml

[cors]
allowed_origins = ["https://app.example.com", "https://admin.example.com"]
allow_credentials = true
max_age = 86400

En-têtes de sécurité (casque)#

Express:

const helmet = require('helmet');
app.use(helmet());

bext.config.toml :

toml

[security.headers]
x_content_type_options = "nosniff"
x_frame_options = "DENY"
x_xss_protection = "1; mode=block"
referrer_policy = "strict-origin-when-cross-origin"
content_security_policy = "default-src 'self'; script-src 'self' 'unsafe-inline'"
strict_transport_security = "max-age=63072000; includeSubDomains; preload"

bext définit ces en-têtes sur chaque réponse. Aucun middleware requis.

Limitation du débit#

Express:

const rateLimit = require('express-rate-limit');
app.use(rateLimit({ windowMs: 60000, max: 100 }));

bext.config.toml :

toml

[rate_limit]
enabled = true
requests_per_minute = 100
distributed = true    # share counters across instances via Redis

Analyse du corps#

Express:

app.use(express.json({ limit: '10mb' }));
app.use(express.urlencoded({ extended: true }));

bext gère automatiquement l'analyse du corps de la requête pour les routes SSR et plugin. Pour les routes proxy en amont, le corps est transmis tel quel. Configurez les limites de taille :

toml

[server]
max_body_size_mb = 10

Compression#

Express:

const compression = require('compression');
app.use(compression());

bext compresse automatiquement les réponses avec Brotli et gzip. Aucune configuration nécessaire : elle est activée par défaut et négociée via Accept-Encoding.

Différences de routage#

Express utilise le chaînage basé sur des méthodes ( app.get(), app.post() ). bext utilise le routage du système de fichiers pour les pages et [[route_rules]] pour les règles basées sur la configuration :

Express:

app.get('/products/:id', (req, res) => { ... });
app.post('/api/orders', (req, res) => { ... });

bext : Placez les gestionnaires de routes dans le système de fichiers :

code

src/
  pages/
    products/
      [id].tsx          # GET /products/:id (SSR page)
  api/
    orders.ts           # POST /api/orders (API route)

Ou configurez les règles de routage :

toml

[[route_rules]]
pattern = "/products/:id"
render = "isr"
ttl_ms = 60000

[[route_rules]]
pattern = "/api/**"
render = "ssr"
headers = { "cache-control" = "no-store" }

Migration WebSocket#

Express + w:

const WebSocket = require('ws');
const wss = new WebSocket.Server({ server });
wss.on('connection', (ws) => { ... });

bext : Utilisez le hub en temps réel intégré :

toml

[realtime]
enabled = true
path = "/ws"
max_connections = 10_000

Le hub en temps réel de bext prend en charge WebSocket et SSE avec des canaux pub/sub, des hooks d'authentification et une reconnexion automatique. Pour une logique WebSocket personnalisée, utilisez un plugin QuickJS ou un proxy vers un serveur WebSocket dédié.

Prise en charge du moteur de modèles#

Si votre application Express utilise Pug, EJS ou guidon pour les modèles côté serveur, vous disposez de deux options :

Migrer vers React /JSX -- Le moteur SSR de bext restitue les composants React de manière native.
Mode proxy -- Conservez Express pour le rendu des modèles, placez bext devant pour TLS, la mise en cache et les ressources statiques.

Garder Express derrière bext (proxy inverse)#

La migration nécessitant le moins d'effort : exécutez Express sur un port local et utilisez bext comme proxy inverse avec TLS, mise en cache, compression et WAF :

toml

[server]
listen = "0.0.0.0:443"
upstream = "http://127.0.0.1:3001"    # your Express app

[tls]
auto_acme = true
acme_email = "admin@example.com"

[cache.isr]
max_entries = 5_000
default_ttl_ms = 30_000

[rate_limit]
enabled = true
requests_per_minute = 600

Démarrez les deux :

bash

# Terminal 1: Express
PORT=3001 node server.js

# Terminal 2: bext
bext-server run

Avec cette configuration, vous obtenez immédiatement :

Auto-TLS avec Let's Encrypt
HTTP/2 et HTTP/3
Brotli + compression gzip
WAF et limitation de débit
Mise en cache ISR (respecte les en-têtes Cache-Control de Express )
Métriques Prometheus à /__bext/metrics

Vous pouvez migrer progressivement les itinéraires de la gestion Express vers la gestion native bext au fil du temps.

Liste de contrôle de migration#

Inventairez votre middleware Express - mappez chacun à une fonctionnalité bext (voir le tableau ci-dessus)
Décidez du remplacement complet ou du proxy inverse
Installez bext et créez bext.config.toml
En cas de remplacement : déplacez les gestionnaires de routes vers les routes du système de fichiers ou [[route_rules]].
En cas de proxy : définissez upstream et démarrez Express sur un port local
Configurer TLS, CORS, la limitation de débit et les en-têtes de sécurité dans bext.config.toml
Exécutez votre suite de tests sur le serveur bext
Supprimer les dépendances Express de la production package.json (si elles sont entièrement remplacées)
Déployer et surveiller les métriques sur /__bext/metrics

Conseil

Le chemin du proxy inverse est la première étape la moins risquée. Vous obtenez Auto-TLS, HTTP/2, la compression brotli et WAF en quelques minutes, puis migrez les routes individuelles vers la gestion native de bext de manière incrémentale, sans réécriture radicale.

En rapport#

Présentation des cadres — frameworks pris en charge et qui offrent le plus de performances
Mise en cache — Cache ISR qui remplace la logique manuelle Cache-Control dans le middleware Express
WebSockets — migration des serveurs ws WebSocket vers le hub temps réel bext
Extensions — portage du middleware Express qui ne correspond pas à une fonctionnalité bext intégrée
Sécurité — bext WAF et limitation de débit remplaçant helmet et express-rate-limit
Référence de configuration — schéma bext.config.toml complet

Links#

expressjs.com — documentation officielle Express.js