Deployer NestJS sur Fly.io

Pourquoi Deployer NestJS sur Fly.io ?

Le déploiement d'une application NestJS sur Fly.io offre plusieurs avantages. En effet, Fly.io propose un service de cloud serverless basé sur Kubernetes, qui permet une mise à l'échelle automatique et la disponibilité accrue. Cela est particulièrement utile pour les applications qui ont une forte variabilité en termes de trafic, comme une API de blog ou un gestionnaire de tâches.

Un cas d'utilisation concret serait le déploiement d'une application de gestion de tâches. Avec Fly.io, on peut facilement échapper aux contraintes matérielles et logicielles traditionnelles en déployant l'application sur des serveurs qui s'étoffissent ou se réduisent en fonction du trafic.

Prerequis

• Connaissance approfondie de NestJS
• Un compte Fly.io
• Node.js (version 14.0 ou plus)
• npm (Node Package Manager)

Concepts fondamentaux

1. Comprendre les conceptes de base de Fly.io

Fly.io est basé sur le modèle serverless, ce qui signifie que vous n'avez pas besoin d'infrastructure pour héberger vos applications. Vous simplement déployer votre code et le reste est géré par la plateforme.

2. Comprendre les routes et la configuration des applications

Pour configurer une application NestJS sur Fly.io, vous devez créer un fichier fly.toml à la racine de votre projet. Ce fichier doit contenir la configuration de base de votre application.

app = "mon-application"
kill_signal = "SIGINT"
kill_timeout = 5000

[build]
  image = "node:14"

[env]
  NODE_ENV = "production"

[[services]]
  internal_port = 3000

  [services.http]
    handlers = ["serve/static", "proxy"]

3. Comprendre les commandes de déploiement

Pour déployer votre application sur Fly.io, vous pouvez utiliser la commande suivante :

fly deploy

Cette commande télécharge votre code sur le serveur Fly.io et le déploie.

Mise en pratique : projet fil rouge

Nous allons créer un petit projet de gestionnaire de tâches pour illustrer ce tutoriel. Le projet comprendra une API RESTful avec des endpoints pour ajouter, récupérer et supprimer des tâches.

1. Initialiser le projet NestJS

nest new task-manager

2. Créer un modèle de données pour les tâches

Dans src/task, créez les fichiers suivants :

task.entity.ts

import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';

@Entity()
export class Task {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  title: string;

  @Column({ default: false })
  completed: boolean;
}

3. Créer un service pour gérer les tâches

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>,
  ) {}

  async findAll(): Promise<Task[]> {
    return this.taskRepository.find();
  }

  async findOne(id: number): Promise<Task> {
    return this.taskRepository.findOne(id);
  }

  async create(task: Task): Promise<Task> {
    return this.taskRepository.save(task);
  }

  async update(id: number, task: Task): Promise<void> {
    await this.taskRepository.update(id, task);
  }

  async remove(id: number): Promise<void> {
    await this.taskRepository.delete(id);
  }
}

4. Créer un contrôleur pour gérer les requêtes

task.controller.ts

import { Controller, Get, Post, Body, Put, Param, Delete } from '@nestjs/common';
import { TaskService } from './task.service';
import { Task } from './task.entity';

@Controller('tasks')
export class TaskController {
  constructor(private readonly taskService: TaskService) {}

  @Get()
  async findAll(): Promise<Task[]> {
    return this.taskService.findAll();
  }

  @Get(':id')
  async findOne(@Param('id') id: number): Promise<Task> {
    return this.taskService.findOne(id);
  }

  @Post()
  async create(@Body() task: Task): Promise<Task> {
    return this.taskService.create(task);
  }

  @Put(':id')
  async update(@Param('id') id: number, @Body() task: Task): Promise<void> {
    await this.taskService.update(id, task);
  }

  @Delete(':id')
  async remove(@Param('id') id: number): Promise<void> {
    await this.taskService.remove(id);
  }
}

5. Configurer la base de données

Ajoutez les dépendances nécessaires dans package.json :

"dependencies": {
  "typeorm": "^0.3.8",
  "pg": "^8.7.1"
},
"devDependencies": {
  "@nestjs/typeorm": "^9.2.0"
}

Créez un fichier ormconfig.json à la racine du projet :

{
  "type": "postgres",
  "host": "localhost",
  "port": 5432,
  "username": "user",
  "password": "password",
  "database": "task_manager",
  "entities": ["dist/src/**/*.entity{.ts,.js}"],
  "synchronize": true
}

6. Configurer TypeORM dans app.module.ts

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { TaskModule } from './task/task.module';

@Module({
  imports: [TaskModule],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

7. Créer le module pour les tâches

task.module.ts

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { TaskController } from './task.controller';
import { TaskService } from './task.service';
import { Task } from './task.entity';

@Module({
  imports: [TypeOrmModule.forFeature([Task])],
  controllers: [TaskController],
  providers: [TaskService],
})
export class TaskModule {}

8. Ajouter des routes pour tester l'API

Vous pouvez utiliser Postman ou curl pour tester les endpoints de votre API.

## Créer une tâche
curl -X POST http://localhost:3000/tasks -H "Content-Type: application/json" -d '{"title": "Faire les courses"}'

## Récupérer toutes les tâches
curl http://localhost:3000/tasks

## Mettre à jour une tâche
curl -X PUT http://localhost:3000/tasks/1 -H "Content-Type: application/json" -d '{"title": "Faire la lessive", "completed": true}'

Erreurs frequentes et debugging

1. Erreur : Error: listen EADDRINUSE: address already in use 3000

Cette erreur signifie que le port 3000 est déjà utilisé sur votre machine. Vous pouvez changer le port dans la configuration de Fly.io.

[[services]]
  internal_port = 3001

2. Erreur : Error: Cannot find module 'typeorm'

Cette erreur signifie que le module TypeORM n'est pas installé. Assurez-vous d'avoir ajouté les dépendances nécessaires dans package.json.

"dependencies": {
  "typeorm": "^0.3.8",
  "pg": "^8.7.1"
}

3. Erreur : Error: listen EACCES: permission denied 3000

Cette erreur signifie que vous n'avez pas les permissions nécessaires pour utiliser le port 3000. Vous pouvez changer le port dans la configuration de Fly.io.

[[services]]
  internal_port = 3001

Pour aller plus loin

1. Utiliser des bases de données externes

Vous pouvez utiliser une base de données externe comme PostgreSQL ou MySQL avec Fly.io pour stocker vos données.

2. Ajouter l'authentification et la sécurité

Pour ajouter une couche d'authentification à votre application, vous pouvez utiliser des packages comme @nestjs/passport et passport-jwt.

3. Créer un dashboard admin avec NestJS et Angular

Vous pouvez créer un dashboard administrateur pour gérer les tâches en utilisant Angular.

Défi pratique

Créez une API de blog simple avec NestJS qui permet d'ajouter, récupérer et supprimer des articles. Utilisez la base de données SQLite pour stocker les articles. Assurez-vous de créer un service et un contrôleur séparés pour gérer les articles.