Home
API
guide

Créer un API avec Node.js et Express : Le Guide Complet

Votre Première API avec Node.js et Express : Le Guide Complet

Bienvenue! Si vous avez déjà entendu parler de la communication entre applications(API) et que vous êtes curieux de savoir comment créer votre propre passerelle de données, vous êtes au bon endroit. Dans ce guide, nous allons construire ensemble une API simple mais fonctionnelle en utilisant Node.js et le framework Express. Préparez votre éditeur de code, ouvrez votre terminal, et lançons-nous !

Prérequis : Avoir Node.js d'Installé

Avant de commencer, assurez-vous que Node.js et npm (Node Package Manager) sont installés sur votre machine. Vous pouvez télécharger Node.js depuis le site officiel : nodejs.org. npm est généralement inclus avec l'installation de Node.js.

Pour vérifier l'installation, ouvrez votre terminal ou invite de commandes et tapez les commandes suivantes :

        node -v
npm -v

Si des numéros de version s'affichent, c'est que tout est en ordre !

Étape 1 : Créer le Dossier de Votre Projet et Initialiser npm

Commençons par créer un nouveau dossier pour notre projet d'API. Ouvrez votre terminal, naviguez vers l'endroit où vous souhaitez créer votre projet et exécutez les commandes suivantes :

        mkdir mon-premiere-api
cd mon-premiere-api

Ensuite, initialisons npm dans ce dossier. Cela va créer un fichier package.json qui contiendra des informations sur notre projet et ses dépendances :

        npm init -y

La commande npm init -y crée le fichier package.json avec les options par défaut.

Étape 2 : Installer Express

Express est un framework Node.js minimaliste et flexible qui simplifie grandement la création d'applications web et d'APIs. Installons-le comme une dépendance de notre projet :

        npm install express

Cette commande va télécharger et installer Express ainsi que ses dépendances dans un dossier node_modules et mettre à jour notre fichier package.json.

Étape 3 : Créer le Fichier Principal de l'API (index.js)

Créez un nouveau fichier nommé index.js à la racine de votre projet. C'est ici que nous allons écrire le code principal de notre API.

Ouvrez index.js et commencez par importer Express et créer une instance de l'application Express :

        const express = require('express');
const app = express();
const port = 3000; // Vous pouvez choisir le port que vous préférez

Ici, nous importons le module Express avec require('express') et nous créons une nouvelle application Express en appelant la fonction express(). Nous définissons également le port sur lequel notre API écoutera les requêtes.

Étape 4 : Définir Votre Première Route

Une route définit un point d'accès (une URL) à votre API et spécifie comment l'API doit répondre aux requêtes adressées à cette URL. Créons une route simple pour la racine de notre API (/) :

        
app.get('/', (req, res) => {
  res.send('Bienvenue sur mon API !');
});

Ici, app.get('/') définit une route qui répondra aux requêtes HTTP GET à l'URL /. La fonction de callback reçoit deux objets : req (la requête) et res (la réponse). Nous utilisons res.send() pour envoyer une simple chaîne de caractères comme réponse.

Étape 5 : Démarrer le Serveur

Pour que notre API soit accessible, nous devons démarrer le serveur. Ajoutez le code suivant à la fin de votre fichier index.js :

        
app.listen(port, () => {
  console.log(`L'API écoute sur le port ${port}`);
});

app.listen(port, ...) démarre le serveur et le fait écouter les connexions sur le port spécifié. La fonction de callback est exécutée une fois que le serveur est démarré.

Étape 6 : Tester Votre Première Route

Ouvrez votre terminal et, depuis le dossier de votre projet, exécutez la commande suivante pour démarrer votre API :

        
node index.js

Vous devriez voir le message "L'API écoute sur le port 3000" (ou le port que vous avez choisi). Ouvrez maintenant votre navigateur et allez à l'adresse http://localhost:3000. Vous devriez voir le message "Bienvenue sur mon API !". Félicitations, votre première route API fonctionne !

Étape 7 : Créer une Route pour Retourner des Données JSON

Les APIs retournent souvent des données structurées au format JSON (JavaScript Object Notation). Créons une nouvelle route qui retourne un tableau d'utilisateurs :

        
const utilisateurs = [
  { id: 1, nom: 'Sam' },
  { id: 2, nom: 'lety' },
  { id: 3, nom: 'Rody' }
];

app.get('/utilisateurs', (req, res) => {
  res.json(utilisateurs);
});

Ici, nous définissons une route /utilisateurs qui utilise res.json() pour envoyer le tableau utilisateurs au format JSON. Redémarrez votre serveur (en arrêtant le processus avec Ctrl+C dans le terminal et en relançant node index.js) et allez à l'adresse http://localhost:3000/utilisateurs dans votre navigateur. Vous devriez voir les données JSON.

Étape 8 : Gérer les Paramètres dans les Routes

Souvent, vous aurez besoin de récupérer des informations spécifiques à partir de l'URL. Express permet de définir des paramètres dans les routes. Par exemple, pour récupérer un utilisateur par son ID :

        
app.get('/utilisateurs/:id', (req, res) => {
  const utilisateurId = parseInt(req.params.id);
  const utilisateur = utilisateurs.find(u => u.id === utilisateurId);

  if (utilisateur) {
    res.json(utilisateur);
  } else {
    res.status(404).send('Utilisateur non trouvé');
  }
});

Dans cette route, :id est un paramètre. Vous pouvez accéder à la valeur de ce paramètre via req.params.id. Nous utilisons parseInt() pour convertir l'ID en nombre entier et Array.prototype.find() pour chercher l'utilisateur correspondant. Si l'utilisateur est trouvé, nous le retournons en JSON. Sinon, nous envoyons un code de statut HTTP 404 (Not Found) et un message.

N'oubliez pas de redémarrer votre serveur après avoir modifié votre code ! Testez cette route en allant à des adresses comme http://localhost:3000/utilisateurs/1 ou http://localhost:3000/utilisateurs/4.

Étape 9 : Gérer les Requêtes POST pour Créer des Ressources

Les requêtes HTTP POST sont souvent utilisées pour créer de nouvelles ressources sur le serveur. Pour gérer les requêtes POST, nous avons besoin d'un middleware pour analyser le corps de la requête (qui contient les données à créer). Le middleware express.json() fait parfaitement l'affaire :

        
app.use(express.json()); // Middleware pour analyser le JSON dans le corps des requêtes

app.post('/utilisateurs', (req, res) => {
  const nouvelUtilisateur = {
    id: utilisateurs.length + 1,
    nom: req.body.nom
  };
  utilisateurs.push(nouvelUtilisateur);
  res.status(201).json(nouvelUtilisateur);
});

Nous ajoutons app.use(express.json()) pour activer le middleware. Dans la route /utilisateurs avec la méthode POST, nous récupérons les données du nouvel utilisateur depuis le corps de la requête (req.body) et nous ajoutons le nouvel utilisateur à notre tableau. Nous envoyons ensuite un code de statut HTTP 201 (Created) et le nouvel utilisateur créé en JSON.

Pour tester cette route, vous pouvez utiliser des outils comme Postman ou Insomnia pour envoyer des requêtes POST avec un corps JSON (par exemple, {"nom": "David"}).

Étape 10 : Servir des Fichiers Statiques (Images, CSS, JavaScript)

Si votre API doit également servir des fichiers statiques comme des images, des feuilles de style CSS ou des fichiers JavaScript pour une interface utilisateur, vous pouvez utiliser le middleware express.static() :

  1. Créez un dossier nommé public à la racine de votre projet.
  2. Placez vos fichiers statiques (par exemple, une image nommée logo.png) dans ce dossier public.
  3. Ajoutez le middleware suivant à votre fichier index.js :
        
app.use(express.static('public'));

Maintenant, vous pouvez accéder à vos fichiers statiques via l'URL http://localhost:3000/logo.png.

Étape 11 : Organiser Vos Routes avec Express Router

Au fur et à mesure que votre API grandit, il est important d'organiser vos routes. Express Router vous permet de créer des modules de routes séparés. Créez un nouveau dossier nommé routes et un fichier à l'intérieur nommé utilisateurs.js :

        
// routes/utilisateurs.js
const express = require('express');
const router = express.Router();

const utilisateurs = [
  { id: 1, nom: 'Sam' },
  { id: 2, nom: 'lety' },
  { id: 3, nom: 'Rody' }
];

// GET /utilisateurs
router.get('/', (req, res) => {
  res.json(utilisateurs);
});

// GET /utilisateurs/:id
router.get('/:id', (req, res) => {
  const utilisateurId = parseInt(req.params.id);
  const utilisateur = utilisateurs.find(u => u.id === utilisateurId);

  if (utilisateur) {
    res.json(utilisateur);
  } else {
    res.status(404).send('Utilisateur non trouvé');
  }
});

// POST /utilisateurs
router.post('/', (req, res) => {
  const nouvelUtilisateur = {
    id: utilisateurs.length + 1,
    nom: req.body.nom
  };
  utilisateurs.push(nouvelUtilisateur);
  res.status(201).json(nouvelUtilisateur);
});

module.exports = router;

Dans votre fichier index.js, importez et utilisez ce routeur :

        
// index.js
const express = require('express');
const app = express();
const port = 3000;
const utilisateursRoutes = require('./routes/utilisateurs');

app.use(express.json());

app.use(express.static('public'));

app.get('/', (req, res) => {
  res.send('Bienvenue sur mon API !');
});

app.use('/utilisateurs', utilisateursRoutes); // Utilisation du routeur pour les routes /utilisateurs

app.listen(port, () => {
  console.log(`L'API écoute sur le port ${port}`);
});

Cela rend votre code plus modulaire et plus facile à gérer .

Conclusion : Vous avez créé votre première API !

Félicitations ! Vous avez parcouru toutes les étapes nécessaires pour créer une API fonctionnelle avec Node.js et Express. Vous savez maintenant comment définir des routes, gérer les paramètres, retourner des données JSON, gérer les requêtes POST et même servir des fichiers statiques. Ce n'est que le début de votre voyage dans le monde des APIs. Continuez à explorer, à expérimenter et à construire des projets plus complexes. Le potentiel est illimité !

Commentaires

  • A+
  • A-