Fastify

Un framework web ultra-rapide pour Node.js, conçu pour offrir performances optimales et une excellente expérience développeur.

Retour aux compétences Documentation officielle

Pour les non-initiés

Qu'est-ce que Fastify ?

Imaginez que vous construisez un site web ou une application qui doit communiquer avec un serveur. Ce serveur doit être capable de recevoir des requêtes, les traiter rapidement et renvoyer des réponses appropriées.

Fastify est un outil qui permet aux développeurs de construire ces serveurs web de manière simple, organisée et surtout extrêmement rapide. C'est comme une boîte à outils spécialement conçue pour créer des applications web performantes avec Node.js.

Pourquoi Fastify est-il utile ?

Performance

Il est conçu pour être extrêmement rapide, capable de traiter des milliers de requêtes par seconde, ce qui est essentiel pour les applications modernes.

Facilité d'utilisation

Malgré sa puissance, il reste simple à prendre en main tout en offrant des fonctionnalités avancées pour les développeurs expérimentés.

En termes simples, Fastify permet de créer des API et des services web qui sont à la fois rapides à développer et rapides à l'exécution, ce qui est crucial dans un monde où les utilisateurs attendent des réponses instantanées.

Pour les développeurs

Caractéristiques et fonctionnement

Fastify est un framework web minimaliste pour Node.js, conçu avec un focus particulier sur les performances et une faible empreinte mémoire. Il fournit une expérience développeur exceptionnelle sans compromettre la vitesse d'exécution.

Installation et configuration

Installation de Fastify et plugins courants

// Installation de Fastify
npm install fastify

// Installation du plugin pour gérer le CORS
npm install @fastify/cors

// Installation du plugin pour la compression
npm install @fastify/compress

// Installation du plugin pour les fichiers statiques
npm install @fastify/static

Fastify est conçu pour être minimal mais extensible. Le cœur du framework est léger, et des fonctionnalités supplémentaires peuvent être ajoutées via un système de plugins robuste.

Exemple de base

Serveur Fastify simple

// Exemple de base avec Fastify
import Fastify from 'fastify'

// Création de l'instance Fastify
const fastify = Fastify({
  logger: true
})

// Déclaration d'une route GET
fastify.get('/', async (request, reply) => {
  return { hello: 'world' }
})

// Démarrage du serveur
const start = async () => {
  try {
    await fastify.listen({ port: 3000 })
  } catch (err) {
    fastify.log.error(err)
    process.exit(1)
  }
}
start()

Ce code simple crée un serveur HTTP qui répond avec un objet JSON {'hello': 'world'} lorsqu'on accède à la route racine. Fastify utilise des Promesses et async/await nativement, ce qui simplifie considérablement la gestion des opérations asynchrones.

Validation avec JSON Schema

Un des points forts de Fastify est son support natif de JSON Schema pour la validation des entrées et sorties, offrant à la fois sécurité et performance:

Validation avec JSON Schema

// Utilisation des schémas JSON pour la validation
import Fastify from 'fastify'
const fastify = Fastify()

const schema = {
  body: {
    type: 'object',
    required: ['name', 'email'],
    properties: {
      name: { type: 'string' },
      email: { type: 'string', format: 'email' },
      age: { type: 'integer', minimum: 18 }
    }
  },
  response: {
    200: {
      type: 'object',
      properties: {
        success: { type: 'boolean' },
        id: { type: 'string' }
      }
    }
  }
}

fastify.post('/user', { schema }, async (request, reply) => {
  // Les données sont automatiquement validées!
  const user = request.body
  
  // Logique pour créer l'utilisateur...
  const id = 'user_' + Math.random().toString(36).substring(2)
  
  return { success: true, id }
})

La validation est compilée en fonctions optimisées lors du démarrage du serveur, ce qui évite tout impact sur les performances à l'exécution.

Système de plugins

L'architecture de Fastify est construite autour d'un système de plugins puissant, qui permet d'encapsuler des fonctionnalités et de les réutiliser:

Création et utilisation d'un plugin

// Création d'un plugin Fastify
import fp from 'fastify-plugin'

async function dbConnector(fastify, options) {
  // Exemple de connexion à une base de données
  const db = await connectToDatabase(options.uri)
  
  // Décorer l'instance Fastify pour ajouter un objet 'db'
  fastify.decorate('db', db)
  
  // Gérer la fermeture de connexion
  fastify.addHook('onClose', (instance, done) => {
    if (db) {
      instance.db.close(done)
    }
  })
}

// Exporter comme plugin
export default fp(dbConnector)

// Utilisation du plugin
import dbPlugin from './plugins/db'

fastify.register(dbPlugin, { 
  uri: 'mongodb://localhost:27017/my_db' 
})

Hooks (Middlewares)

Fastify offre un système de hooks complet pour exécuter du code à différentes étapes du cycle de vie de la requête:

Utilisation des hooks

// Utilisation des hooks dans Fastify
fastify.addHook('onRequest', async (request, reply) => {
  // Exécuté pour chaque demande avant le routage
  request.log.info('Nouvelle requête entrante')
})

fastify.addHook('preHandler', async (request, reply) => {
  // Exécuté après le routage, mais avant le gestionnaire
  if (!request.user && request.url !== '/login') {
    throw new Error('Non authentifié')
  }
})

fastify.addHook('onResponse', async (request, reply) => {
  // Exécuté après l'envoi de la réponse
  request.log.info({
    url: request.url,
    statusCode: reply.statusCode,
    responseTime: reply.getResponseTime()
  })
})

Performances exceptionnelles

Fastify vs Express vs Koa (benchmark)

Les benchmarks montrent que Fastify est significativement plus performant que d'autres frameworks Node.js populaires:

Framework	Requêtes/sec	Latence (ms)
Fastify	~60,000	~1.5
Express	~25,000	~4.0
Koa	~30,000	~3.5

*Les résultats peuvent varier selon la configuration du serveur et le type de requêtes.

Applications concrètes

Cas d'usage

APIs REST à haut débit

Idéal pour les API qui doivent gérer un grand nombre de requêtes avec une faible latence, comme les services de paiement, d'authentification ou d'analyse de données.

Microservices

Parfait pour construire une architecture de microservices, où chaque service est léger, performant et n'utilise que les dépendances dont il a besoin.

Applications serverless

Son démarrage rapide et sa faible empreinte mémoire en font un excellent choix pour les environnements serverless comme AWS Lambda.

Applications temps réel

Combiné avec des technologies comme Socket.IO, Fastify excelle dans les applications nécessitant des communications en temps réel.

Avantages et limitations

Avantages

Performance exceptionnelle - Jusqu'à 2x plus rapide qu'Express
Validation intégrée - Support natif de JSON Schema
TypeScript ready - Support complet des types TypeScript
Écosystème de plugins - Extensions modulaires pour tous les besoins
Faible empreinte mémoire - Important pour les environnements contraints

Limitations

Communauté moins large - Plus petit que celle d'Express
Moins de ressources éducatives - Moins de tutoriels et d'exemples
Certains plugins peuvent manquer - Pour des fonctionnalités très spécifiques
Courbe d'apprentissage - Pour les concepts avancés comme les plugins

Damien Gilbrin

Ce que j'ai fait avec Fastify

J'ai utilisé Fastify chez BFMTV sur le site BFMTV.com comme backend du front et pour les appels API. Nous avons choisi Fastify pour sa performance supérieure par rapport à Express.js, un facteur crucial pour un site d'information à fort trafic.

L'implémentation de Fastify nous a permis de construire des APIs REST capables de gérer des millions de requêtes quotidiennes avec une latence minimale. J'ai particulièrement apprécié son système de validation par JSON Schema qui nous a permis de sécuriser efficacement toutes nos API, tout en bénéficiant d'une génération automatique de documentation.

Nous avons également tiré parti de l'architecture de plugins de Fastify pour modulariser notre code, ce qui a considérablement amélioré la maintenabilité de notre base de code, particulièrement importante dans un environnement où plusieurs équipes travaillent sur différentes parties de l'application.