Pourquoi Deployer NestJS sur Railway ?
Deployer NestJS sur Railway offre plusieurs avantages pratiques :
- Accès à des environnements pré-configurés : Railway fournit un environnement prêt à l'emploi avec toutes les dépendances nécessaires, ce qui permet de se concentrer sur le développement plutôt que la configuration.
- Facilité d'extension et de mise à l'échelle : Avec une plateforme comme Railway, il est facile d'ajouter des ressources supplémentaires (CPU, RAM) en quelques clics pour satisfaire à la demande croissante de votre application.
- Intégration continue et livraison continue (CI/CD) : Railway offre des fonctionnalités de CI/CD intégrées qui permettent d'automatiser les tests et le déploiement de vos applications, facilitant ainsi le processus de développement Agile.
Un cas concret serait une petite application de gestionnaire de tâches. Imaginez que vous travaillez sur un projet personnel où vous devez suivre et gérer vos tâches quotidiennes. En déployant ce gestionnaire sur Railway, vous pourriez partager votre application avec d'autres membres de la famille ou du projet, en assurant ainsi une accessibilité facile et sécurisée.
Prerequis
Avant de commencer à déployer un projet NestJS sur Railway, il est important de disposer des éléments suivants :
- Un compte GitHub valide (pour héberger votre code)
- Un compte Railway valide
- Node.js installé sur votre machine (version recommandée : 14.x ou ultérieure)
- npm ou yarn installés sur votre machine
Concepts fondamentaux
Concept 1 : Lien du Repository GitHub
Pour déployer une application NestJS sur Railway, vous devez d'abord créer un dépôt GitHub pour héberger votre code.
## Créez un nouveau répertoire pour votre projet et initialisez-le avec Git
mkdir my-nestjs-app
cd my-nestjs-app
git init
## Initialisez un nouveau projet NestJS (si ce n'est pas déjà fait)
npm install -g @nestjs/cli
nest new .
## Ajoutez les fichiers au dépôt GitHub
git add .
git commit -m "Initial commit"
Concept 2 : Créer un Compte sur Railway
Si vous ne possédez pas déjà un compte sur Railway, allez sur le site web de Railway (https://railway.app/) et suivez les instructions pour créer un nouveau compte.
## Une fois votre compte créé, connectez-vous à votre espace de travail
Concept 3 : Créer une Nouvelle Application sur Railway
Connectez-vous à votre compte Railway et allez dans la section "New App". Choisissez le dépôt GitHub que vous avez créé pour votre projet NestJS.
## Sélectionnez le dépôt GitHub dans l'interface de création d'une nouvelle application
Concept 4 : Configuration du Projet
Railway va automatiquement déployer votre application NestJS en utilisant les scripts start et build définis dans le fichier package.json. Assurez-vous que ces scripts sont correctement configurés.
{
"scripts": {
"prebuild": "rimraf dist",
"build": "nest build",
"format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
"lint": "eslint src --ext .ts",
"start": "node dist/main"
}
}
Concept 5 : Déploiement Auto
Une fois votre application configurée, Railway va déployer automatiquement l'application à chaque push sur le dépôt GitHub. Vous pouvez vérifier le statut du déploiement dans la section "Deployments" de votre application sur Railway.
## Assurez-vous que le déploiement est réussi et que votre application fonctionne correctement
Mise en pratique : Projet Fil Rouge
Comme mentionné précédemment, nous allons construire un gestionnaire de tâches simple. Voici les étapes pour créer un projet complet.
Étape 1 : Créer le Projet NestJS
## Initialisez un nouveau projet NestJS
nest new task-manager
cd task-manager
Étape 2 : Ajouter les Entités et Services
Créez une entité Task et un service TaskService.
## Créez l'entité Task
nest generate entity task
## Créez le service TaskService
nest generate service task
Étape 3 : Définir les Entités et Services
Modifier la classe TaskEntity dans task.entity.ts :
// src/task/task.entity.ts
import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
@Entity()
export class Task {
@PrimaryGeneratedColumn()
id: number;
@Column({ type: 'varchar', length: 255 })
title: string;
@Column({ type: 'boolean', default: false })
completed: boolean;
}
Modifier la classe TaskService dans task.service.ts :
// src/task/task.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Task } from './task.entity';
@Injectable()
export class TaskService {
constructor(
@InjectRepository(Task)
private readonly taskRepository: Repository<Task>,
) {}
findAll(): Promise<Task[]> {
return this.taskRepository.find();
}
findOne(id: number): Promise<Task> {
return this.taskRepository.findOne(id);
}
async create(task: Task): Promise<Task> {
const newTask = this.taskRepository.create(task);
return this.taskRepository.save(newTask);
}
async update(id: number, task: Task): Promise<Task> {
await this.taskRepository.update(id, task);
return this.findOne(id);
}
async remove(id: number): Promise<void> {
await this.taskRepository.delete(id);
}
}
Étape 4 : Créer les Controllers
Créez un controller pour gérer les requêtes HTTP.
## Créez le controller TaskController
nest generate controller task
Modifier la classe TaskController dans task.controller.ts :
// src/task/task.controller.ts
import { Controller, Get, Post, Put, Delete, Param, Body } from '@nestjs/common';
import { TaskService } from './task.service';
import { Task } from './task.entity';
@Controller('tasks')
export class TaskController {
constructor(private readonly taskService: TaskService) {}
@Get()
findAll(): Promise<Task[]> {
return this.taskService.findAll();
}
@Get(':id')
findOne(@Param('id') id: string): Promise<Task> {
return this.taskService.findOne(+id);
}
@Post()
create(@Body() task: Task): Promise<Task> {
return this.taskService.create(task);
}
@Put(':id')
update(@Param('id') id: string, @Body() task: Task): Promise<Task> {
return this.taskService.update(+id, task);
}
@Delete(':id')
remove(@Param('id') id: string): Promise<void> {
return this.taskService.remove(+id);
}
}
Étape 5 : Ajouter les Dépendances
Ajoutez les dépendances nécessaires dans package.json :
{
"dependencies": {
"@nestjs/common": "^8.0.0",
"@nestjs/core": "^8.0.0",
"@nestjs/typeorm": "^8.0.0",
"typeorm": "^0.3.7"
},
"devDependencies": {
"typescript": "~4.2.3",
"prettier": "^2.3.2",
"eslint": "^7.29.0",
"@nestjs/cli": "^8.0.0",
"@nestjs/schematics": "^8.0.0"
}
}
Étape 6 : Créer le Fichier ormconfig.json
Créez un fichier ormconfig.json pour configurer TypeORM :
// ormconfig.json
{
"type": "postgres",
"host": "localhost",
"port": 5432,
"username": "your_username",
"password": "your_password",
"database": "task_manager",
"synchronize": true,
"logging": false,
"entities": ["dist/**/*.entity{.ts,.js}"],
"migrations": ["dist/migrations/**/*{.ts,.js}"],
"subscribers": ["dist/subscribers/**/*{.ts,.js}"]
}
Étape 7 : Configurer le Fichier main.ts
Ajoutez les modules nécessaires dans main.ts :
// src/main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { TypeOrmModule } from '@nestjs/typeorm';
async function bootstrap() {
const app = await NestFactory.create(AppModule);
await app.listen(3000);
}
bootstrap();
Étape 8 : Créer le Fichier app.module.ts
Ajoutez les modules nécessaires dans app.module.ts :
// src/app.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { TaskController } from './task/task.controller';
import { TaskService } from './task/task.service';
import { TaskEntity } from './task/task.entity';
@Module({
imports: [
TypeOrmModule.forRoot({
type: 'postgres',
host: 'localhost',
port: 5432,
username: 'your_username',
password: 'your_password',
database: 'task_manager',
entities: [TaskEntity],
synchronize: true,
}),
TypeOrmModule.forFeature([TaskEntity]),
],
controllers: [TaskController],
providers: [TaskService],
})
export class AppModule {}
Étape 9 : Ajouter les Scripts
Ajoutez les scripts nécessaires dans package.json :
{
"scripts": {
"prebuild": "rimraf dist",
"build": "nest build",
"format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
"lint": "eslint src --ext .ts",
"start": "node dist/main"
}
}
Étape 10 : Lancer le Projet
Lancez le projet local pour vous assurer qu'il fonctionne correctement.
## Installez les dépendances
npm install
## Lancez l'application
npm run start
Erreurs Frequentes et Debugging
Erreur 1 : Error: connect ECONNREFUSED localhost:5432
Code Incorrect :
// src/task/task.service.ts
const newTask = this.taskRepository.create(task);
return this.taskRepository.save(newTask);
Code Correct :
// src/task/task.service.ts
const newTask = this.taskRepository.create(task);
return this.taskRepository.save(newTask).catch(err => {
console.error('Error saving task:', err);
throw err;
});
Erreur 2 : Error: Cannot find module '@nestjs/typeorm'
Code Incorrect :
// src/task/task.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Task } from './task.entity';
@Injectable()
export class TaskService {
constructor(
@InjectRepository(Task)
private readonly taskRepository: Repository<Task>,
) {}
findAll(): Promise<Task[]> {
return this.taskRepository.find();
}
}
Code Correct :
// src/task/task.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Task } from './task.entity';
@Injectable()
export class TaskService {
constructor(
@InjectRepository(Task)
private readonly taskRepository: Repository<Task>,
) {}
findAll(): Promise<Task[]> {
return this.taskRepository.find();
}
}
Erreur 3 : Error: EACCES: permission denied, open 'dist/main.js'
Code Incorrect :
// src/task/task.service.ts
const newTask = this.taskRepository.create(task);
return this.taskRepository.save(newTask).catch(err => {
console.error('Error saving task:', err);
throw err;
});
Code Correct :
// src/task/task.service.ts
const newTask = this.taskRepository.create(task);
return this.taskRepository.save(newTask).catch(err => {
console.error('Error saving task:', err);
throw err;
});
Pour aller plus loin
Piste 1 : Ajouter des Authentification et Autorisation
L'ajout d'une authentification et d'autorisation est une étape cruciale pour sécuriser votre application. Utilisez Passport.js ou JWT (JSON Web Tokens) pour ajouter ces fonctionnalités.
Lien vers la documentation de Passport.js
Piste 2 : Optimiser les Requêtes SQL
Optimisez vos requêtes SQL en utilisant des jointures et des index. TypeORM propose des outils pour optimiser les performances de votre application.
Lien vers la documentation de TypeORM
Piste 3 : Créer une API GraphQL
Ajoutez une couche GraphQL à votre application NestJS pour permettre aux clients d'accéder et de modifier vos données de manière flexible et puissante.
Lien vers la documentation de NestJS sur GraphQL
Défi Pratique
Créez un gestionnaire de tâches complet avec des fonctionnalités avancées comme l'authentification, les autorisations, et une interface utilisateur front-end. Partagez votre code sur GitHub et déployez-le sur Railway.