Skip to content
Learni
Voir tous les tutoriels
Backend

Comment créer une API REST avec Fastify en 2026

14 minINTERMEDIATE
TypeScriptAPI RESTFastify
Read in English

Introduction

Fastify est un framework web Node.js reconnu pour sa vitesse exceptionnelle et sa faible empreinte mémoire. Il excelle dans la création d'APIs REST grâce à son système de plugins, sa validation intégrée et son support natif de TypeScript. En 2026, il reste le choix privilégié pour les applications nécessitant de hautes performances sans sacrifier la maintenabilité. Ce tutoriel vous guide pas à pas pour construire une API complète et production-ready.

Prérequis

  • Node.js 20+
  • npm ou pnpm
  • Connaissances de base en TypeScript
  • Compréhension des concepts REST

Initialisation du projet

terminal
mkdir fastify-api && cd fastify-api
npm init -y
npm install fastify
npm install -D typescript @types/node tsx
npx tsc --init

Cette commande initialise le projet, installe Fastify et configure TypeScript. tsx permet d'exécuter directement le code TypeScript en développement.

Configuration TypeScript

Modifiez le fichier tsconfig.json pour activer les options strictes et les modules ES. Cela garantit un code plus sûr et moderne.

Serveur de base avec Fastify

src/server.ts
import Fastify from 'fastify';

const fastify = Fastify({ logger: true });

fastify.get('/', async (request, reply) => {
  return { message: 'API Fastify opérationnelle' };
});

const start = async () => {
  try {
    await fastify.listen({ port: 3000, host: '0.0.0.0' });
  } catch (err) {
    fastify.log.error(err);
    process.exit(1);
  }
};

start();

Ce serveur minimal expose un endpoint GET et utilise le logger intégré de Fastify. La fonction start gère le démarrage asynchrone et les erreurs de manière robuste.

Ajout de routes avec validation

src/routes/users.ts
import { FastifyInstance } from 'fastify';

export default async function userRoutes(fastify: FastifyInstance) {
  fastify.get('/users', {
    schema: {
      response: { 200: { type: 'array', items: { type: 'object' } } }
    }
  }, async () => {
    return [{ id: 1, name: 'Alice' }];
  });

  fastify.post('/users', {
    schema: {
      body: {
        type: 'object',
        properties: { name: { type: 'string' } },
        required: ['name']
      }
    }
  }, async (request) => {
    return { id: 2, name: request.body.name };
  });
}

Les schémas JSON intégrés à Fastify valident automatiquement les requêtes et réponses. Cela améliore la sécurité et les performances sans dépendance externe.

Enregistrement des plugins

src/server.ts
import Fastify from 'fastify';
import userRoutes from './routes/users';

const fastify = Fastify({ logger: true });

fastify.register(userRoutes, { prefix: '/api' });

const start = async () => {
  try {
    await fastify.listen({ port: 3000 });
  } catch (err) {
    fastify.log.error(err);
    process.exit(1);
  }
};

start();

L'encapsulation via register permet d'organiser le code en modules indépendants. Le prefix évite les conflits de routes et structure proprement l'API.

Gestion des erreurs et hooks

src/server.ts
fastify.setErrorHandler((error, request, reply) => {
  fastify.log.error(error);
  reply.status(500).send({ error: 'Erreur interne' });
});

fastify.addHook('onRequest', async (request) => {
  request.log.info('Requête reçue');
});

Le gestionnaire d'erreurs centralisé et les hooks permettent de logger et traiter les exceptions de façon uniforme dans toute l'application.

Bonnes pratiques

  • Utilisez systématiquement les schémas de validation
  • Organisez le code en plugins réutilisables
  • Activez le logger en production avec des niveaux adaptés
  • Séparez configuration et logique métier
  • Testez chaque route avec des outils comme Vitest

Erreurs courantes à éviter

  • Oublier d'utiliser async/await avec les handlers
  • Définir des schémas incomplets qui laissent passer des données invalides
  • Ignorer la gestion des erreurs asynchrones
  • Ne pas configurer CORS pour les applications frontend

Pour aller plus loin

Approfondissez Fastify avec l'authentification JWT et les tests automatisés. Découvrez nos formations Learni pour maîtriser les architectures backend avancées.