Contactez-nous

Maîtriser Node.js de débutant à expert

Devenez un expert Node.js ! Formation complète pour maîtriser JavaScript serveur, de l'installation aux déploiements avancés. Projets pratiques, Express, NestJS, API & bases de données.

Table des matières

  1. Introduction à Node.js et à son environnement
    1. Qu'est-ce que Node.js ?
      1. Naissance et philosophie de Node.js
      2. Le moteur JavaScript V8
      3. Pourquoi choisir Node.js ? (avantages et cas d'utilisation)
      4. Node.js vs. autres technologies back-end
      5. L'écosystème Node.js : un aperçu
    2. Installation et configuration de l'environnement
      1. Téléchargement et installation de Node.js (différentes méthodes)
      2. Utilisation de NVM (Node Version Manager)
      3. Installation et gestion des dépendances avec npm (Node Package Manager)
      4. Introduction à yarn : un gestionnaire de paquets alternatif
      5. Configuration d'un environnement de développement (IDE, outils)
      6. Votre premier programme "Hello, World!" en Node.js
    3. Les bases du JavaScript pour Node.js
      1. Rappels essentiels : variables, types de données, opérateurs
      2. Structures de contrôle (conditionnelles, boucles)
      3. Fonctions et portée des variables
      4. Objets et prototypes en JavaScript
      5. Les nouveautés d'ECMAScript (ES6+) : let, const, arrow functions, classes, etc.
  2. Le coeur de Node.js : Asynchronisme et modules
    1. Le modèle asynchrone de Node.js
      1. Programmation synchrone vs. asynchrone
      2. La boucle d'événements (event loop) : le coeur de Node.js
      3. Comprendre les callbacks (fonctions de rappel)
      4. Gestion des erreurs dans un contexte asynchrone
      5. Introduction aux timers (setTimeout, setInterval)
    2. Gestion de l'asynchronisme avancé
      1. Les promesses (Promises) : une approche moderne de l'asynchronisme
      2. Chaînage de promesses et gestion des erreurs avec .then() et .catch()
      3. Async/await : simplifier l'écriture du code asynchrone
      4. Combiner callbacks, promesses et async/await
      5. Bonnes pratiques pour une gestion optimale de l'asynchronisme
    3. Le système de modules Node.js
      1. Introduction aux modules : organisation du code
      2. Modules CommonJS : require() et module.exports
      3. Modules ES (ECMAScript Modules) : import et export
      4. Création et publication de vos propres modules npm
      5. Modules natifs de Node.js (core modules) : fs, http, path, etc.
      6. Résolution de modules et gestion des conflits
  3. Manipulation des données et du système
    1. Gestion des flux de données (Streams)
      1. Introduction aux streams : pourquoi utiliser des flux ?
      2. Types de streams : Readable, Writable, Duplex, Transform
      3. Lecture et écriture de données avec les streams
      4. Gestion des erreurs et des événements de cycle de vie des streams
      5. Pipes : connecter les streams entre eux
      6. Exemples pratiques : streaming de fichiers, traitement de données en temps réel
    2. Interaction avec le système de fichiers (fs)
      1. Lecture de fichiers (synchrone et asynchrone)
      2. Ecriture de fichiers (synchrone et asynchrone)
      3. Création, suppression et renommage de fichiers et de répertoires
      4. Gestion des permissions et des métadonnées des fichiers
      5. Surveillance des changements dans le système de fichiers (fs.watch)
      6. Utilisation de chemins relatifs et absolus (module path)
    3. Buffers : manipulation de données binaires
      1. Introduction aux buffers : représentation des données binaires
      2. Création et manipulation de buffers
      3. Encodage et décodage de données (UTF-8, ASCII, etc.)
      4. Utilisation de buffers avec les streams et le système de fichiers
      5. Considérations de performance et de sécurité avec les buffers
  4. Développement d'applications web avec Node.js
    1. Création d'un serveur HTTP
      1. Le module http : bases de la communication HTTP
      2. Création d'un serveur HTTP simple
      3. Gestion des requêtes et des réponses (request, response)
      4. En-têtes HTTP (headers)
      5. Codes de statut HTTP (200 OK, 404 Not Found, etc.)
      6. Redirections et gestion des erreurs
    2. Express.js : le framework web incontournable
      1. Installation et configuration d'Express.js
      2. Gestion des routes : définir les points d'accès de votre API
      3. Middlewares : traitement des requêtes en amont
      4. Gestion des paramètres de requête (query parameters, route parameters)
      5. Envoi de données JSON et HTML
      6. Utilisation de moteurs de template (EJS, Pug, Handlebars)
    3. Gestion des données côté serveur
      1. Introduction aux bases de données (SQL et NoSQL)
      2. Connexion à une base de données MySQL avec le module mysql
      3. Connexion à une base de données MongoDB avec le module mongodb ou Mongoose
      4. Création, lecture, mise à jour et suppression de données (CRUD)
      5. Modélisation des données avec Mongoose (schémas, modèles)
      6. Validation des données et gestion des erreurs
    4. Authentification et autorisation
      1. Concepts de base : authentification vs. autorisation
      2. Mise en place d'un système d'authentification simple (avec sessions)
      3. Utilisation de JWT (JSON Web Tokens) pour l'authentification
      4. Gestion des rôles et des permissions (autorisation)
      5. Sécurisation des API avec des middlewares d'authentification
      6. Intégration avec des fournisseurs d'identité tiers (OAuth 2.0)
    5. WebSockets : communication en temps réel
      1. Introduction aux WebSockets : communication bidirectionnelle
      2. Mise en place d'un serveur WebSocket avec le module ws ou Socket.IO
      3. Envoi et réception de messages en temps réel
      4. Gestion des connexions et des déconnexions
      5. Exemples d'applications : chat, jeux en ligne, notifications push
  5. Tests, débogage et performances
    1. Tests unitaires et d'intégration
      1. Importance des tests : qualité et maintenabilité du code
      2. Frameworks de test : Jest, Mocha, Chai
      3. Ecriture de tests unitaires : tester des fonctions individuelles
      4. Ecriture de tests d'intégration : tester l'interaction entre les modules
      5. Mocking et stubbing : isoler les dépendances lors des tests
      6. Couverture de code (code coverage)
    2. Débogage et profilage
      1. Utilisation du débogueur intégré de Node.js
      2. Débogage avec les outils de développement du navigateur (Chrome DevTools)
      3. Utilisation de `console.log` et d'autres outils de logging
      4. Profilage des performances : identifier les goulots d'étranglement
      5. Outils de profilage avancés (clinic.js, 0x)
      6. Gestion des erreurs et des exceptions : try...catch, uncaughtException
    3. Optimisation des performances
      1. Mesurer les performances : benchmarking
      2. Optimisation du code JavaScript (algorithmes, structures de données)
      3. Optimisation de la boucle d'événements : éviter les opérations bloquantes
      4. Utilisation de caches (mémoire, Redis)
      5. Mise à l'échelle horizontale (clustering, load balancing)
      6. Compression des réponses
  6. Architecture, bonnes pratiques et déploiement
    1. Architecture et patterns de conception
      1. Principes SOLID
      2. Modularité et séparation des préoccupations (separation of concerns)
      3. Pattern MVC (Model-View-Controller)
      4. Introduction aux microservices
      5. Autres patterns de conception courants (Factory, Singleton, Observer, etc.)
    2. Bonnes pratiques de développement Node.js
      1. Gestion de la configuration (dotenv, config)
      2. Gestion des secrets (ne jamais stocker de mots de passe en clair !)
      3. Utilisation d'un linter (ESLint) et d'un formateur de code (Prettier)
      4. Documentation du code (JSDoc)
      5. Gestion des versions avec Git et GitHub
      6. Sécurité : prévention des attaques courantes (XSS, CSRF, SQL injection)
    3. Déploiement d'applications Node.js
      1. Préparation de l'application pour la production
      2. Utilisation de PM2 pour gérer les processus Node.js
      3. Déploiement sur un serveur traditionnel (VPS, serveur dédié)
      4. Déploiement sur une plateforme cloud (Heroku, AWS, Google Cloud, Azure)
      5. Utilisation de Docker pour conteneuriser les applications
      6. Introduction au serverless (AWS Lambda, Google Cloud Functions, Azure Functions)
  7. Outils, écosystème et concepts avancés
    1. L'écosystème Node.js : outils et frameworks
      1. Présentation de frameworks populaires : Koa.js, NestJS, Fastify
      2. Outils de build : Webpack, Parcel, Rollup
      3. ORM/ODM : Sequelize, Mongoose, TypeORM
      4. Librairies de gestion des API : Swagger, OpenAPI
      5. Outils de monitoring et de logging : Winston, Morgan, New Relic, Datadog
    2. Concepts avancés
      1. Travailleurs (worker threads) : parallélisation des tâches
      2. Clustering : exploitation des multiples coeurs du processeur
      3. Programmation réactive avec RxJS
      4. Développement d'applications en ligne de commande (CLI)
      5. Création d'addons natifs avec Node-API (N-API) anciennement NAN
    3. Intégration continue et déploiement continu (CI/CD)
      1. Principes de l'intégration continue et du déploiement continu
      2. Mise en place d'un pipeline CI/CD avec des outils comme Jenkins, Travis CI, CircleCI, GitHub Actions
      3. Tests automatisés dans le pipeline CI/CD
      4. Déploiement automatisé sur différentes plateformes
  8. Etudes de cas et projets pratiques
    1. Projet 1 : Création d'une API RESTful
      1. Conception de l'API (endpoints, modèles de données)
      2. Implémentation avec Express.js et MongoDB
      3. Tests unitaires et tests d'intégration
      4. Documentation de l'API avec Swagger
      5. Déploiement sur Heroku
    2. Projet 2 : Développement d'une application de chat en temps réel
      1. Conception de l'application (fonctionnalités, interface utilisateur)
      2. Mise en place du serveur WebSocket avec Socket.IO
      3. Création du client (frontend) avec HTML, CSS et JavaScript
      4. Gestion des utilisateurs et des messages
      5. Déploiement sur un serveur cloud
    3. Projet 3 : Mise en place d'une architecture microservices
      1. Définition des différents microservices (authentification, gestion des utilisateurs, gestion des produits, etc.)
      2. Communication entre les microservices (API REST, messages queues)
      3. Utilisation de Docker et Docker Compose pour orchestrer les microservices
      4. Déploiement sur une plateforme cloud (Kubernetes)
    4. Tendances et avenir de Node.js
      1. Evolutions récentes de Node.js
      2. Le futur de JavaScript et de l'écosystème Node.js
      3. Nouvelles technologies et frameworks émergents
      4. Rester à jour : veille technologique et communauté