API modernes avec Fastify dans Node.js

Fasitify est-il la meilleure option pour créer une API Node.js moderne ? Nous allons jeter un coup d’oeil.

JavaScript est devenu le langage de programmation le plus populaire au monde. L’écosystème s’est considérablement développé et mûri au cours des 10 dernières années. De nombreuses communautés, projets et frameworks open source ont été créés depuis lors et ont aidé le langage à devenir ce qu’il est aujourd’hui.

Le développement de Node.js a transformé la possibilité de créer JavaScript à un tout autre niveau. À partir de quelque chose qui ne peut fonctionner que sur un navigateur, nous pouvons créer quelque chose qui peut fonctionner sur notre machine en tant qu’application. Depuis lors, Node.js est devenu le moyen le plus simple de créer des API modernes et rapides de nos jours.

La possibilité de créer une API Node.js à partir de zéro en quelques minutes est ce qui la rend si populaire parmi les développeurs. L’écosystème que Node.js apporte aux développeurs facilite la création d’API capables de gérer de nombreuses requêtes simultanées sans affaiblir le serveur.

De nombreux frameworks ont été construits pour nous aider à créer des API modernes à l’aide de Node.js. Le plus connu et le plus utilisé est Express. Express est un cadre d’application Web Node.js minimal et flexible qui fournit un ensemble robuste de fonctionnalités pour développer des applications Node.js. C’est le framework Node.js le plus célèbre, mais Express en a quelques-uns points douloureux cela pourrait vous faire reconsidérer son utilisation pour créer votre API Node.js. À sa place, vous devriez regarder Fastify.

Fastifier

Fastifier est un framework Web moderne pour Node.js qui vise à fournir la meilleure expérience de développement avec le moins de frais généraux et une architecture de plug-in puissante. Il a été inspiré par Marche d’escalier, Restifier et Exprimer.

Fastify est conçu comme un framework Web à usage général, mais il brille lors de la création d’API HTTP extrêmement rapides qui utilisent JSON comme format de données. Il a pour objectif d’améliorer le débit de nombreuses applications Web et mobiles sans compromettre le débit et les performances, afin que quiconque souhaite l’utiliser puisse créer des API HTTP extrêmement rapides avec une faible surcharge.

Un serveur performant implique un moindre coût de l’infrastructure, une meilleure réactivité en charge et des utilisateurs satisfaits. Comment pouvez-vous gérer efficacement les ressources de votre serveur, sachant que vous traitez le plus grand nombre de requêtes possible, sans sacrifier les validations de sécurité et le développement pratique ?

Passons en revue quelques-unes des fonctionnalités qui rendent Fastify si performant :

• Rapide : capable de traiter jusqu’à 30 000 requêtes par seconde (selon la complexité du code)
• Entièrement extensible via ses hooks, plugins et décorateurs
• Expressif et convivial pour les développeurs
• Prêt pour TypeScript
• Schéma JSON basé sur une fonction hautement performante
• Journalisation à faible coût

Maintenant que nous en savons un peu plus sur les fonctionnalités de Fastify, créons une API simple en l’utilisant et comprenons mieux ce qui rend Fastify si spécial.

Commencer

Pour démarrer avec Fastify, la première chose à faire est d’installer Fastify :

yarn add fastify

Après l’avoir installé, nous pouvons importer Fastify dans notre fichier et l’instancier :

import Fastify from 'fastify';
 
const fastify = Fastify();

Enregistrement

Fastifier les usages pino en tant que bûcheron. La journalisation est désactivée par défaut dans Fastify, mais nous pouvons l’activer en transmettant une propriété de journalisation à notre instance Fastify. Nous devons en être conscients car la journalisation est désactivée par défaut et il n’est pas possible de l’activer lors de l’exécution.

import Fastify from 'fastify';

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

Routage

Les méthodes de routage configureront les points de terminaison de votre API, et Fastify le gère de manière simple et puissante. Il existe deux manières de déclarer des routes avec Fastify : déclaration abrégée ou déclaration complète.

La déclaration abrégée est plus facile à écrire et à lire. Ça va comme ça:

fastify.get(path, [options], handler);

Il prend en charge toutes les opérations telles que PUBLIER, METTRE, EFFACER, etc. Utilisons l’opération get pour créer notre première route à l’aide de Fastify. Nous allons retourner un simple Hello world! message sur notre route.

import Fastify from 'fastify';

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

fastify.get("https://www.telerik.com/", (req, reply) => {
  reply.send('Hello world!');
});

Fastify a été inspiré par Express, la syntaxe semble donc familière. Le req et la réponse représentent la demande et la réponse (réponse).

Maintenant que notre première route est configurée, il est temps pour nous de faire fonctionner notre serveur. Pour ce faire, nous utiliserons la méthode fastify.listen. Il renvoie une promesse et nous allons créer une fonction qui gère cette promesse en utilisant async et await.

import Fastify from 'fastify';

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

fastify.get("https://www.telerik.com/", (req, reply) => {
  reply.send('Hello world!');
});

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

Plugins

Avec Fastify, tout est un plugin. Il propose un modèle de plugin similaire à Hapi (un autre framework Node.js qui a inspiré Fastify). Il ajoute une encapsulation complète des plugins afin que chaque plugin puisse utiliser ses dépendances et ses crochets s’il le souhaite.

L’utilisation de plugins avec Fastify facilite la création d’API réutilisables et découplées. Il gère parfaitement le code asynchrone et garantit l’ordre de chargement et l’ordre de fermeture des plugins.

Nous allons créer notre premier plugin en utilisant Fastify, et pour cela nous allons créer un autre fichier. Nommons notre nouveau fichier first_plugin, et à l’intérieur de ce fichier nous allons déclarer une nouvelle route.

function (fastify, opts, next) {
  fastify.get('/first', (req, reply) => {
    reply.send('First plugin using Fastify!')
  });

  next();
});

Maintenant, dans notre fichier principal, nous allons importer notre fichier first_plugin et utiliser l’API register, qui est au cœur du framework Fastify. C’est le seul moyen d’ajouter des routes, des plugins, etc.

import Fastify from 'fastify';

import firstPlugin from './first-plugin'

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

fastify.get("https://www.telerik.com/", (req, reply) => {
  reply.send('Hello world!');
});

fastify.register(firstPlugin);

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

Facile, non ? Fastify a tout un écosystème plein de plugins maintenus par l’équipe Fastify que vous pouvez utiliser.

Conclusion

Fastify a été conçu dès le départ pour être aussi rapide que possible et nous pouvons dire qu’il offre tout ce que nous attendons. Fastify est un framework Node.js puissant pour créer des API modernes fiables et performantes. Les fonctionnalités puissantes qu’il offre, telles que la journalisation, les plugins, la validation, la sérialisation et le schéma fluide, en font la meilleure option viable pour créer une API Node.js moderne.

Fastify est un framework qui ne se limite pas seulement à l’architecture REST. Nous pouvons créer l’utiliser pour créer des services GraphQL et gRPC en l’utilisant et les rendre plus performants.