Créer et exécuter un projet NestJS localement sur macOS avec ServBay

NestJS est un framework Node.js progressif conçu pour construire des applications serveur efficaces et évolutives. Écrit en TypeScript et inspiré par Angular, il repose sur une architecture modulaire et un système d’injection de dépendances (DI). NestJS fournit de puissants outils afin de faciliter la création d’applications complexes, maintenables, testables et hautement découplées.

Atouts et principales caractéristiques de NestJS

• Architecture modulaire : Organisez votre code via des modules pour rendre votre application plus structurée, compréhensible et facile à maintenir.
• Injection de dépendances : Un écosystème d’injection de dépendances performant et simple d’utilisation, maximisant la testabilité et la maintenabilité de votre code.
• Utilisation de TypeScript : Profitez de la vérification statique des types, des interfaces et des dernières fonctionnalités JavaScript pour booster votre productivité et la qualité de votre code tout en diminuant les erreurs à l’exécution.
• Décorateurs riches : Les décorateurs vous permettent de déclarer simplement contrôleurs, services, modules, etc., pour un code plus clair, déclaratif et explicite.
• Écosystème robuste : Une communauté active, de nombreux modules tiers et plugins facilitent l’intégration de fonctionnalités telles que TypeORM, Mongoose, GraphQL, WebSockets, la mise en cache, la validation, etc.
• Basé sur les standards : Construit sur des serveurs HTTP matures (Express ou Fastify), assurant compatibilité et hautes performances.

Avec NestJS, les développeurs peuvent appliquer les meilleures pratiques du développement backend (principe SOLID, design patterns…) pour concevoir rapidement des applications web, des APIs et des microservices puissants et prêts pour l’entreprise.

Créer et exécuter un projet NestJS avec ServBay

ServBay offre un environnement de développement web puissant et intégré pour macOS, comprenant plusieurs versions de Node.js, des bases de données populaires et des serveurs web. Ce guide explique comment utiliser l’environnement Node.js et la fonction « Site » de ServBay pour créer et paramétrer un projet NestJS. Grâce à la fonctionnalité proxy inverse de ServBay, vous pouvez accéder à votre application NestJS locale via un domaine personnalisé.

Prérequis

Avant de commencer, assurez-vous d’avoir effectué les actions suivantes :

1. Installer ServBay : ServBay est bien installé sur votre macOS.
2. Activer le package Node.js : Dans l’onglet « Packages » du panneau de contrôle ServBay, sélectionnez et installez la version souhaitée de Node.js. Si Node.js n’a pas encore été activé, consultez le Guide d'utilisation de Node.js avec ServBay pour la configuration.

Initialisation du projet NestJS

1. Installer le CLI NestJS globalement

   Ouvrez le terminal et installez l’outil CLI NestJS globalement avec npm (installé avec Node.js). Cet outil CLI simplifie l’initialisation, le développement et la maintenance de vos applications NestJS.

   npm install -g @nestjs/cli

2. Créer le projet

   Placez-vous dans le dossier racine des sites recommandé par ServBay : /Applications/ServBay/www. Ce répertoire est idéal pour héberger votre projet et le configurer par la suite. Générez ensuite un nouveau projet NestJS :

   cd /Applications/ServBay/www
   nest new servbay-nest-app

   Après cette commande, l’assistant du CLI vous guide dans la création : choix du gestionnaire de paquets (npm, yarn ou pnpm – nous recommandons npm pour plus de cohérence). Le projet sera créé dans /Applications/ServBay/www/servbay-nest-app.

3. Installer les dépendances

   Accédez au dossier de votre projet servbay-nest-app et installez les dépendances nécessaires :

   cd servbay-nest-app
   npm install

   La commande nest new exécute déjà npm install, mais relancer cette commande garantit que tout est à jour.

Modifier la réponse par défaut du projet NestJS (optionnel)

Pour valider que le projet fonctionne et qu’il est accessible via ServBay, vous pouvez modifier la route racine du projet afin de retourner une chaîne de caractères personnalisée.

1. Modifier le fichier src/app.controller.ts

   Ouvrez src/app.controller.ts avec votre éditeur favori. Modifiez son contenu comme ci-dessous afin qu’un accès à la racine (/) retourne la chaîne "Hello ServBay!" :

   import { Controller, Get } from '@nestjs/common';
   import { AppService } from './app.service'; // Supposons que vous gardiez AppService
   
   @Controller()
   export class AppController {
     constructor(private readonly appService: AppService) {} // Si vous gardez AppService
   
     @Get()
     getHello(): string {
       // return this.appService.getHello(); // Si vous utilisez AppService
       return 'Hello ServBay!'; // Retourne une chaîne directement
     }
   }

   Ce contrôleur gère la route GET / et renvoie la chaîne spécifiée en réponse.

Démarrer le projet NestJS en mode développement et y accéder via ServBay

En développement, NestJS s’exécute avec son serveur intégré, à l’écoute d’un port choisi. Avec la fonctionnalité « Site » de ServBay, configurez un proxy inverse pour associer un domaine personnalisé à ce port.

1. Démarrer le serveur de développement

   Placez-vous dans le dossier /Applications/ServBay/www/servbay-nest-app et lancez le serveur de développement. Définissez la variable d’environnement PORT — par exemple, à 8585.

   cd /Applications/ServBay/www/servbay-nest-app
   PORT=8585 npm run start:dev

   npm run start:dev utilise ts-node pour exécuter le code TypeScript avec surveillance des fichiers. Le serveur sera accessible sur localhost:8585.

2. Configurer le proxy inverse sur ServBay

   Depuis le panneau de contrôle ServBay, allez dans l’onglet « Sites ». Cliquez sur le bouton Ajouter (+) pour créer une nouvelle configuration :

   • Nom (Name) : Par exemple Mon premier site NestJS dev.
   • Domaines (Domains) : Le domaine local souhaité, comme servbay-nest-test.dev. ServBay résout automatiquement les domaines en .dev localement, inutile de modifier le fichier hosts.
   • Type : Choisissez Proxy Inverse (Reverse Proxy).
   • Adresse IP (IP Address) : Généralement 127.0.0.1 (boucle locale).
   • Port : Le port d’écoute de NestJS, ici 8585.

   Enregistrez. ServBay applique automatiquement la configuration à son serveur web (Caddy ou Nginx). Pour plus d’infos, consultez la documentation Ajouter un site ServBay.

3. Accéder au site en mode développement

   Dans votre navigateur, ouvrez l’URL : https://servbay-nest-test.dev.

   Remarques :

   • ServBay fourni gratuitement un certificat SSL pour chaque site local (délivré par ServBay User CA), ainsi l’accès est sécurisé en https. Si une alerte certificat apparaît, il suffit de faire confiance à l’autorité ServBay User CA. Plus d’infos dans Sécuriser un site avec SSL.
   • Assurez-vous que votre serveur de développement NestJS (PORT=8585 npm run start:dev) fonctionne. Sinon, le domaine ne sera pas accessible.

Déployer la version de production et y accéder via ServBay

Avant le déploiement en production (y compris pour des simulations locales), il est nécessaire de construire le projet.

1. Construire la version de production

   Dans le dossier /Applications/ServBay/www/servbay-nest-app :

   cd /Applications/ServBay/www/servbay-nest-app
   npm run build

   Cette commande compile le code source TypeScript dans le répertoire dist.

2. Lancer le serveur en production

   Une fois la compilation terminée, démarrez l’application NestJS version production avec :

   cd /Applications/ServBay/www/servbay-nest-app
   PORT=8586 NODE_ENV=production node dist/main.js

   En production, il n’y a ni hot-reload ni surveillance des fichiers.

3. Configurer le proxy inverse pour la production

   Retournez dans l’onglet « Sites » du panneau ServBay et créez/modifiez une configuration pour pointer vers la version production :

   • Nom (Name) : Par exemple Mon premier site NestJS production.
   • Domaines (Domains) : Par exemple servbay-nest-test.prod.
   • Type (Type) : Proxy Inverse (Reverse Proxy).
   • Adresse IP (IP Address) : 127.0.0.1.
   • Port : 8586 (doit correspondre au port du serveur Node.js de production).

   Enregistrez la configuration.

4. Accéder au site en mode production

   Visitez https://servbay-nest-test.prod dans un navigateur pour découvrir la version production de l’application. ServBay assure le chiffrement SSL.

Connexion aux bases de données fournies par ServBay

ServBay inclut et supporte plusieurs systèmes de base de données, parmi lesquels MariaDB (compatible MySQL), PostgreSQL, MongoDB et Redis. Lors du développement avec NestJS, vous pouvez facilement connecter ces services à votre application.

Attention : Avant toute tentative de connexion, vérifiez que le package de base de données correspondant est activé dans l’onglet « Packages » du panneau de contrôle ServBay. Les ports, identifiants et mots de passe par défaut sont disponibles via l’interface ServBay ou la documentation associée. Pour la production, il est fortement recommandé de changer ces identifiants par défaut et de créer des utilisateurs dédiés.

Voici des exemples de configuration pour connecter un projet NestJS aux bases ServBay via des ORM/bibliothèques courantes. Placez ces configurations dans le module racine (AppModule) ou un module base de données dédié.

1. Connexion à MongoDB

   Utilisez @nestjs/mongoose pour MongoDB. Installez d’abord les packages nécessaires :

   npm install @nestjs/mongoose mongoose

   Puis configurez MongooseModule dans votre module NestJS :

   import { Module } from '@nestjs/common';
   import { MongooseModule } from '@nestjs/mongoose';
   // ... autres imports
   
   @Module({
     imports: [
       MongooseModule.forRoot('mongodb://localhost:27017/servbay-nest-app'), // Port par défaut 27017
       // ... autres modules
     ],
     controllers: [], // ...
     providers: [], // ...
   })
   export class AppModule {}

   L’URL par défaut de MongoDB ServBay est mongodb://localhost:27017/. Créez la base servbay-nest-app via un client MongoDB (Compass, mongosh, etc.)

2. Connexion à Redis

   Utilisez @nestjs/redis pour Redis. Installez :

   npm install @nestjs/redis redis @types/redis

   Puis configurez RedisModule :

   import { Module } from '@nestjs/common';
   import { RedisModule } from '@nestjs/redis';
   // ... autres imports
   
   @Module({
     imports: [
       RedisModule.forRoot({
         url: 'redis://localhost:6379', // Port par défaut 6379
       }),
       // ... autres modules
     ],
     controllers: [], // ...
     providers: [], // ...
   })
   export class AppModule {}

   L’adresse Redis ServBay par défaut est localhost:6379.

3. Connexion à MariaDB (compatible MySQL)

   Utilisez @nestjs/typeorm pour MariaDB/MySQL (ServBay gère les deux, protocoles compatibles). D’abord, installez :

   npm install @nestjs/typeorm mysql2 typeorm

   Puis configurez TypeOrmModule :

   import { Module } from '@nestjs/common';
   import { TypeOrmModule } from '@nestjs/typeorm';
   // ... autres imports
   
   @Module({
     imports: [
       TypeOrmModule.forRoot({
         type: 'mariadb', // ou 'mysql'
         host: 'localhost',
         port: 3306, // Par défaut
         username: 'root', // Utilisateur root par défaut ServBay
         password: 'password', // Mot de passe root par défaut ServBay
         database: 'servbay_nest_app', // À créer au préalable
         entities: [], // Tableau de vos entités
         synchronize: true, // Ok en développement, à éviter en production
       }),
       // ... autres modules
     ],
     controllers: [], // ...
     providers: [], // ...
   })
   export class AppModule {}

   Remarque : Le mot de passe root par défaut pour MariaDB/MySQL sur ServBay est password. Utilisez votre client (TablePlus, DBeaver, ligne de commande…) pour créer la base servbay_nest_app sur localhost:3306 en tant que root/password. Par sécurité, changez le mot de passe “root” et créez un utilisateur à droits réduits pour l’app.

4. Connexion à PostgreSQL

   Utilisez également @nestjs/typeorm. Installez :

   npm install @nestjs/typeorm pg typeorm

   Puis configurez :

   import { Module } from '@nestjs/common';
   import { TypeOrmModule } from '@nestjs/typeorm';
   // ... autres imports
   
   @Module({
     imports: [
       TypeOrmModule.forRoot({
         type: 'postgres',
         host: 'localhost',
         port: 5432, // Par défaut
         username: 'servbay', // Exemple de user par défaut, à vérifier selon votre config
         password: 'password', // Exemple de mot de passe par défaut, à vérifier
         database: 'servbay_nest_app', // À créer au préalable
         entities: [], // Vos entités
         synchronize: true, // Ok en développement, à éviter en production
       }),
       // ... autres modules
     ],
     controllers: [], // ...
     providers: [], // ...
   })
   export class AppModule {}

   Remarque : Selon la version ServBay, l’utilisateur/password par défaut pour PostgreSQL peut varier (par exemple servbay ou postgres). Consultez le panneau ou la documentation ServBay pour obtenir la liste exacte, puis créez la base servbay_nest_app et l’utilisateur dédié au besoin. En production, changez bien tous les identifiants par défaut.

Résumé

Grâce à ce guide, vous savez maintenant comment utiliser ServBay pour créer, exécuter et accéder rapidement à un projet NestJS en environnement local sur macOS. Avec l’intégration de Node.js, la gestion facilitée des sites (notamment le proxy inverse) et la prise en charge de multiples bases de données, ServBay simplifie grandement le développement et les tests de vos applications NestJS. Basculez facilement entre les modes développement et production, accédez à vos apps en toute sécurité via des domaines personnalisés en HTTPS, et connectez-les sans effort aux puissants services de base de données intégrés de ServBay.