⚡️ Node.js – Installation, Core & Déploiement

http (Serveur natif)

Le module http permet de créer un serveur web "bas niveau". (Express.js l'utilise en interne).

const http = require('http');

// 'req' (Request), 'res' (Response)
const server = http.createServer((req, res) => {
  
  if (req.url === '/') {
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('Accueil\n');
  } else if (req.url === '/json') {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ status: 'ok' }));
  } else {
    res.writeHead(404);
    res.end('Not Found\n');
  }
  
});

server.listen(3000, '127.0.0.1', () => {
  console.log('Serveur démarré sur http://127.0.0.1:3000');
});

events (EventEmitter)

De nombreux objets Node (streams, http) héritent de EventEmitter. C'est le pattern "Observer" (Pub/Sub).

const EventEmitter = require('events');

class MonEmetteur extends EventEmitter {}
const emetteur = new MonEmetteur();

// 1. S'abonner à l'événement 'alerte'
emetteur.on('alerte', (data) => {
  console.log('Alerte reçue !', data);
});

// (Une seule fois)
emetteur.once('connexion', () => {
  console.log('Connecté !');
});

// 2. Émettre les événements
emetteur.emit('connexion');
emetteur.emit('alerte', { code: 'rouge' });
emetteur.emit('connexion'); // (Ne fait rien)

Buffer (Données Binaires)

JavaScript n'était pas conçu pour les données binaires. Node a introduit Buffer pour gérer les octets (ex: lire une image, données TCP).

// Alloue un buffer de 10 octets (vide)
const buf1 = Buffer.alloc(10);

// Crée un buffer depuis un string
const buf2 = Buffer.from('Bonjour');

console.log(buf2);
//  (Hex)

console.log(buf2.toString('utf8'));
// 'Bonjour'

Stream (Flux de données)

Pour gérer des données volumineuses (ex: un fichier de 5Go), on ne peut pas tout charger en RAM (Buffer). On utilise un Stream (flux).

.pipe() est la méthode la plus efficace pour "tuyauter" un flux lisible (Readable) vers un flux écrivable (Writable).

const fs = require('fs');
const http = require('http');

// Cas 1: Mauvais (bloque 5Go de RAM)
http.createServer((req, res) => {
  const data = fs.readFileSync('video.mp4'); // 5Go
  res.end(data);
});

// Cas 2: Bon (Stream)
http.createServer((req, res) => {
  // Crée un flux de lecture
  const readStream = fs.createReadStream('video.mp4');
  
  // "Pipe" le flux du fichier vers la réponse HTTP
  // (La RAM reste faible)
  readStream.pipe(res);
});

Le "Callback Hell" (Pyramide)

L'ancienne méthode de gestion asynchrone consistait à passer des fonctions (callbacks) en dernier argument. Pour chaîner des opérations, on tombe dans le "Callback Hell".

Logique : 1. Lire config -> 2. Lire BDD -> 3. Écrire fichier

const fs = require('fs');

fs.readFile('config.json', 'utf8', (err1, configData) => {
  if (err1) {
    console.error("Erreur config", err1);
  } else {
    
    // (Supposez que 'db.query' est aussi async)
    db.query(configData.sql, (err2, dbData) => {
      if (err2) {
        console.error("Erreur BDD", err2);
      } else {
        
        fs.writeFile('output.txt', dbData, (err3) => {
          if (err3) {
            console.error("Erreur écriture", err3);
          } else {
            console.log("Terminé !");
          }
        });
        
      }
    });
    
  }
});

Sucre syntaxique pour les Promises

async/await (ES2017) est une syntaxe qui permet d'écrire du code asynchrone (basé on Promises) comme s'il était synchrone.

• async function : Déclare une fonction qui retourne implicitement une Promise.
• await : Met en "pause" l'exécution de la fonction (sans bloquer le thread) en attendant que la Promise soit résolue.
• try...catch : Gère les erreurs (les "rejects").

Exemple (remplace 3.2)

const { readFile, writeFile } = require('fs/promises');

// 1. 'async'
async function main() {
  try {
    // 2. 'await' (attend la résolution)
    const configData = await readFile('config.json', 'utf8');
    
    // 3. 'await' (attend la BDD)
    const dbData = await db.query(configData.sql);
    
    // 4. 'await' (attend l'écriture)
    await writeFile('output.txt', dbData);
    
    console.log("Terminé !");
    
  } catch (err) {
    // 5. 'catch' (gère les erreurs)
    console.error("Une erreur est survenue:", err);
  } finally {
    db.close();
  }
}

// Lancer la fonction
main();

Le framework web de facto

Personne n'utilise le module http (cf 2.4) en production. Express.js est un micro-framework minimaliste qui simplifie le routage, la gestion des middlewares et les réponses.

Installation

npm install express

app.js (Hello World)

const express = require('express');

// 1. Créer l'application
const app = express();
const port = 3000;

// 2. Définir une route (le "Routing")
// (req = Request, res = Response)
app.get('/', (req, res) => {
  // .send() est plus simple que .end()
  res.send('Bonjour, IDEO-Lab !');
});

app.get('/json', (req, res) => {
  // .json() gère le Content-Type auto
  res.json({ status: 'ok' });
});

// 3. Démarrer le serveur
app.listen(port, () => {
  console.log(`Serveur démarré sur http://localhost:${port}`);
});

npm install pg

node-postgres (pg) est le driver principal pour PostgreSQL. Il est entièrement asynchrone (basé sur Promises).

Configuration (Pool de connexions)

Ne créez pas un client par requête. Créez un **Pool** (singleton) et réutilisez-le.

// db.js
const { Pool } = require('pg');

const pool = new Pool({
  user: 'db_user',
  host: 'localhost',
  database: 'ideo_lab_db',
  password: 'db_password',
  port: 5432,
});

module.exports = {
  query: (text, params) => pool.query(text, params),
};

Utilisation (Async/Await)

// app.js
const express = require('express');
const db = require('./db');
const app = express();

app.get('/users', async (req, res) => {
  try {
    const { rows } = await db.query('SELECT * FROM users');
    res.json(rows);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

app.get('/users/:id', async (req, res) => {
  try {
    const { id } = req.params;
    
    // Protection contre l'injection SQL
    const { rows } = await db.query(
      'SELECT * FROM users WHERE id = $1',
      [id]
    );
    
    res.json(rows[0]);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

Axios

Pour appeler d'autres APIs (microservices, APIs externes) depuis Node, axios est la librairie la plus populaire (basée sur Promises).

npm install axios

GET

const axios = require('axios');

async function getUsers() {
  try {
    const response = await axios.get('https://api.example.com/users');
    console.log(response.data); // Données JSON
  } catch (error) {
    console.error(error.response.data); // Erreur de l'API
  }
}

POST

async function createUser(nom) {
  try {
    const response = await axios.post('https://api.example.com/users', {
      nom: nom,
      status: 'actif'
    });
    console.log(response.data);
  } catch (error) {
    console.error(error);
  }
}

// (axios.put, axios.delete...)

Architecture de Production

PM2 (Node.js) écoute sur un port local (ex: 3000). Nginx écoute sur le port public (80/443) et agit en "reverse proxy".

[Internet] (Port 80/443)
    |
    ▼
[Nginx (Reverse Proxy)]
 (TLS, Cache, Compression)
    |
    | (proxy_pass)
    ▼
[PM2 / Node.js] (Port 3000)
 (Clustered)

Configuration Nginx

# /etc/nginx/sites-available/node-app
upstream nodejs_app {
    # PM2 écoute ici (localhost:3000)
    server 127.0.0.1:3000;
}

server {
    listen 80;
    server_name node-app.ideolab.com;
    
    location / {
        proxy_pass http://nodejs_app;
        
        # Headers essentiels
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        
        # Pour les WebSockets
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

NVM (Gestionnaire de versions)

nvm install --lts
nvm install 20
nvm use 20
nvm ls
nvm alias default 20

NPM (Gestionnaire de paquets)

npm init -y
npm install express
npm i -D nodemon
npm install # (ou 'npm i')
npm run dev
npm run start
npm list --depth=0
npm uninstall express

Modules (Core)

// CJS (Défaut)
const fs = require('fs');
module.exports = { ... };

// ESM ("type": "module")
import fs from 'fs';
export { ... };
export default ...;

// FS (Async/Promise)
import { readFile, writeFile } from 'fs/promises';
const data = await readFile('file.txt', 'utf8');

// Path
const path = require('path');
path.join(__dirname, 'views');
path.resolve('..', 'file.txt');